1//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Format/Format.h"
10
11#include "../Tooling/ReplacementTest.h"
12#include "FormatTestUtils.h"
13
14#include "llvm/Support/Debug.h"
15#include "llvm/Support/MemoryBuffer.h"
16#include "gtest/gtest.h"
17
18#define DEBUG_TYPE "format-test"
19
20using clang::tooling::ReplacementTest;
21using clang::tooling::toReplacements;
22using testing::internal::ScopedTrace;
23
24namespace clang {
25namespace format {
26namespace {
27
28FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
29
30class FormatTest : public ::testing::Test {
31protected:
32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
33
34 std::string format(llvm::StringRef Code,
35 const FormatStyle &Style = getLLVMStyle(),
36 StatusCheck CheckComplete = SC_ExpectComplete) {
37 LLVM_DEBUG(llvm::errs() << "---\n");
38 LLVM_DEBUG(llvm::errs() << Code << "\n\n");
39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
40 FormattingAttemptStatus Status;
41 tooling::Replacements Replaces =
42 reformat(Style, Code, Ranges, "<stdin>", &Status);
43 if (CheckComplete != SC_DoNotCheck) {
44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
46 << Code << "\n\n";
47 }
48 ReplacementCount = Replaces.size();
49 auto Result = applyAllReplacements(Code, Replaces);
50 EXPECT_TRUE(static_cast<bool>(Result));
51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
52 return *Result;
53 }
54
55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
56 Style.ColumnLimit = ColumnLimit;
57 return Style;
58 }
59
60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
62 }
63
64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
66 }
67
68 void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
69 llvm::StringRef Code,
70 const FormatStyle &Style = getLLVMStyle()) {
71 ScopedTrace t(File, Line, ::testing::Message() << Code.str());
72 EXPECT_EQ(Expected.str(), format(Expected, Style))
73 << "Expected code is not stable";
74 EXPECT_EQ(Expected.str(), format(Code, Style));
75 if (Style.Language == FormatStyle::LK_Cpp) {
76 // Objective-C++ is a superset of C++, so everything checked for C++
77 // needs to be checked for Objective-C++ as well.
78 FormatStyle ObjCStyle = Style;
79 ObjCStyle.Language = FormatStyle::LK_ObjC;
80 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
81 }
82 }
83
84 void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
85 const FormatStyle &Style = getLLVMStyle()) {
86 _verifyFormat(File, Line, Code, test::messUp(Code), Style);
87 }
88
89 void _verifyIncompleteFormat(const char *File, int Line, llvm::StringRef Code,
90 const FormatStyle &Style = getLLVMStyle()) {
91 ScopedTrace t(File, Line, ::testing::Message() << Code.str());
92 EXPECT_EQ(Code.str(),
93 format(test::messUp(Code), Style, SC_ExpectIncomplete));
94 }
95
96 void _verifyIndependentOfContext(const char *File, int Line,
97 llvm::StringRef Text,
98 const FormatStyle &Style = getLLVMStyle()) {
99 _verifyFormat(File, Line, Text, Style);
100 _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(),
101 Style);
102 }
103
104 /// \brief Verify that clang-format does not crash on the given input.
105 void verifyNoCrash(llvm::StringRef Code,
106 const FormatStyle &Style = getLLVMStyle()) {
107 format(Code, Style, SC_DoNotCheck);
108 }
109
110 int ReplacementCount;
111};
112
113#define verifyIndependentOfContext(...) \
114 _verifyIndependentOfContext(__FILE__, __LINE__, __VA_ARGS__)
115#define verifyIncompleteFormat(...) \
116 _verifyIncompleteFormat(__FILE__, __LINE__, __VA_ARGS__)
117#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
118#define verifyGoogleFormat(Code) verifyFormat(Code, getGoogleStyle())
119
120TEST_F(FormatTest, MessUp) {
121 EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
122 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
123 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
124 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
125 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
126}
127
128TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
129 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
130}
131
132TEST_F(FormatTest, LLVMStyleOverride) {
133 EXPECT_EQ(FormatStyle::LK_Proto,
134 getLLVMStyle(FormatStyle::LK_Proto).Language);
135}
136
137//===----------------------------------------------------------------------===//
138// Basic function tests.
139//===----------------------------------------------------------------------===//
140
141TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
142 EXPECT_EQ(";", format(";"));
143}
144
145TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
146 EXPECT_EQ("int i;", format(" int i;"));
147 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));
148 EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));
149 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));
150}
151
152TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
153 EXPECT_EQ("int i;", format("int\ni;"));
154}
155
156TEST_F(FormatTest, FormatsNestedBlockStatements) {
157 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));
158}
159
160TEST_F(FormatTest, FormatsNestedCall) {
161 verifyFormat("Method(f1, f2(f3));");
162 verifyFormat("Method(f1(f2, f3()));");
163 verifyFormat("Method(f1(f2, (f3())));");
164}
165
166TEST_F(FormatTest, NestedNameSpecifiers) {
167 verifyFormat("vector<::Type> v;");
168 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
169 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
170 verifyFormat("static constexpr bool Bar = typeof(bar())::value;");
171 verifyFormat("static constexpr bool Bar = __underlying_type(bar())::value;");
172 verifyFormat("static constexpr bool Bar = _Atomic(bar())::value;");
173 verifyFormat("bool a = 2 < ::SomeFunction();");
174 verifyFormat("ALWAYS_INLINE ::std::string getName();");
175 verifyFormat("some::string getName();");
176}
177
178TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
179 EXPECT_EQ("if (a) {\n"
180 " f();\n"
181 "}",
182 format("if(a){f();}"));
183 EXPECT_EQ(4, ReplacementCount);
184 EXPECT_EQ("if (a) {\n"
185 " f();\n"
186 "}",
187 format("if (a) {\n"
188 " f();\n"
189 "}"));
190 EXPECT_EQ(0, ReplacementCount);
191 EXPECT_EQ("/*\r\n"
192 "\r\n"
193 "*/\r\n",
194 format("/*\r\n"
195 "\r\n"
196 "*/\r\n"));
197 EXPECT_EQ(0, ReplacementCount);
198}
199
200TEST_F(FormatTest, RemovesEmptyLines) {
201 EXPECT_EQ("class C {\n"
202 " int i;\n"
203 "};",
204 format("class C {\n"
205 " int i;\n"
206 "\n"
207 "};"));
208
209 // Don't remove empty lines at the start of namespaces or extern "C" blocks.
210 EXPECT_EQ("namespace N {\n"
211 "\n"
212 "int i;\n"
213 "}",
214 format("namespace N {\n"
215 "\n"
216 "int i;\n"
217 "}",
218 getGoogleStyle()));
219 EXPECT_EQ("/* something */ namespace N {\n"
220 "\n"
221 "int i;\n"
222 "}",
223 format("/* something */ namespace N {\n"
224 "\n"
225 "int i;\n"
226 "}",
227 getGoogleStyle()));
228 EXPECT_EQ("inline namespace N {\n"
229 "\n"
230 "int i;\n"
231 "}",
232 format("inline namespace N {\n"
233 "\n"
234 "int i;\n"
235 "}",
236 getGoogleStyle()));
237 EXPECT_EQ("/* something */ inline namespace N {\n"
238 "\n"
239 "int i;\n"
240 "}",
241 format("/* something */ inline namespace N {\n"
242 "\n"
243 "int i;\n"
244 "}",
245 getGoogleStyle()));
246 EXPECT_EQ("export namespace N {\n"
247 "\n"
248 "int i;\n"
249 "}",
250 format("export namespace N {\n"
251 "\n"
252 "int i;\n"
253 "}",
254 getGoogleStyle()));
255 EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
256 "\n"
257 "int i;\n"
258 "}",
259 format("extern /**/ \"C\" /**/ {\n"
260 "\n"
261 "int i;\n"
262 "}",
263 getGoogleStyle()));
264
265 // ...but do keep inlining and removing empty lines for non-block extern "C"
266 // functions.
267 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
268 EXPECT_EQ("extern \"C\" int f() {\n"
269 " int i = 42;\n"
270 " return i;\n"
271 "}",
272 format("extern \"C\" int f() {\n"
273 "\n"
274 " int i = 42;\n"
275 " return i;\n"
276 "}",
277 getGoogleStyle()));
278
279 // Remove empty lines at the beginning and end of blocks.
280 EXPECT_EQ("void f() {\n"
281 "\n"
282 " if (a) {\n"
283 "\n"
284 " f();\n"
285 " }\n"
286 "}",
287 format("void f() {\n"
288 "\n"
289 " if (a) {\n"
290 "\n"
291 " f();\n"
292 "\n"
293 " }\n"
294 "\n"
295 "}",
296 getLLVMStyle()));
297 EXPECT_EQ("void f() {\n"
298 " if (a) {\n"
299 " f();\n"
300 " }\n"
301 "}",
302 format("void f() {\n"
303 "\n"
304 " if (a) {\n"
305 "\n"
306 " f();\n"
307 "\n"
308 " }\n"
309 "\n"
310 "}",
311 getGoogleStyle()));
312
313 // Don't remove empty lines in more complex control statements.
314 EXPECT_EQ("void f() {\n"
315 " if (a) {\n"
316 " f();\n"
317 "\n"
318 " } else if (b) {\n"
319 " f();\n"
320 " }\n"
321 "}",
322 format("void f() {\n"
323 " if (a) {\n"
324 " f();\n"
325 "\n"
326 " } else if (b) {\n"
327 " f();\n"
328 "\n"
329 " }\n"
330 "\n"
331 "}"));
332
333 // Don't remove empty lines before namespace endings.
334 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
335 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
336 EXPECT_EQ("namespace {\n"
337 "int i;\n"
338 "\n"
339 "}",
340 format("namespace {\n"
341 "int i;\n"
342 "\n"
343 "}",
344 LLVMWithNoNamespaceFix));
345 EXPECT_EQ("namespace {\n"
346 "int i;\n"
347 "}",
348 format("namespace {\n"
349 "int i;\n"
350 "}",
351 LLVMWithNoNamespaceFix));
352 EXPECT_EQ("namespace {\n"
353 "int i;\n"
354 "\n"
355 "};",
356 format("namespace {\n"
357 "int i;\n"
358 "\n"
359 "};",
360 LLVMWithNoNamespaceFix));
361 EXPECT_EQ("namespace {\n"
362 "int i;\n"
363 "};",
364 format("namespace {\n"
365 "int i;\n"
366 "};",
367 LLVMWithNoNamespaceFix));
368 EXPECT_EQ("namespace {\n"
369 "int i;\n"
370 "\n"
371 "}",
372 format("namespace {\n"
373 "int i;\n"
374 "\n"
375 "}"));
376 EXPECT_EQ("namespace {\n"
377 "int i;\n"
378 "\n"
379 "} // namespace",
380 format("namespace {\n"
381 "int i;\n"
382 "\n"
383 "} // namespace"));
384
385 FormatStyle Style = getLLVMStyle();
386 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
387 Style.MaxEmptyLinesToKeep = 2;
388 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
389 Style.BraceWrapping.AfterClass = true;
390 Style.BraceWrapping.AfterFunction = true;
391 Style.KeepEmptyLinesAtTheStartOfBlocks = false;
392
393 EXPECT_EQ("class Foo\n"
394 "{\n"
395 " Foo() {}\n"
396 "\n"
397 " void funk() {}\n"
398 "};",
399 format("class Foo\n"
400 "{\n"
401 " Foo()\n"
402 " {\n"
403 " }\n"
404 "\n"
405 " void funk() {}\n"
406 "};",
407 Style));
408}
409
410TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
411 verifyFormat("x = (a) and (b);");
412 verifyFormat("x = (a) or (b);");
413 verifyFormat("x = (a) bitand (b);");
414 verifyFormat("x = (a) bitor (b);");
415 verifyFormat("x = (a) not_eq (b);");
416 verifyFormat("x = (a) and_eq (b);");
417 verifyFormat("x = (a) or_eq (b);");
418 verifyFormat("x = (a) xor (b);");
419}
420
421TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
422 verifyFormat("x = compl(a);");
423 verifyFormat("x = not(a);");
424 verifyFormat("x = bitand(a);");
425 // Unary operator must not be merged with the next identifier
426 verifyFormat("x = compl a;");
427 verifyFormat("x = not a;");
428 verifyFormat("x = bitand a;");
429}
430
431//===----------------------------------------------------------------------===//
432// Tests for control statements.
433//===----------------------------------------------------------------------===//
434
435TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
436 verifyFormat("if (true)\n f();\ng();");
437 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
438 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
439 verifyFormat("if constexpr (true)\n"
440 " f();\ng();");
441 verifyFormat("if CONSTEXPR (true)\n"
442 " f();\ng();");
443 verifyFormat("if constexpr (a)\n"
444 " if constexpr (b)\n"
445 " if constexpr (c)\n"
446 " g();\n"
447 "h();");
448 verifyFormat("if CONSTEXPR (a)\n"
449 " if CONSTEXPR (b)\n"
450 " if CONSTEXPR (c)\n"
451 " g();\n"
452 "h();");
453 verifyFormat("if constexpr (a)\n"
454 " if constexpr (b) {\n"
455 " f();\n"
456 " }\n"
457 "g();");
458 verifyFormat("if CONSTEXPR (a)\n"
459 " if CONSTEXPR (b) {\n"
460 " f();\n"
461 " }\n"
462 "g();");
463
464 FormatStyle AllowsMergedIf = getLLVMStyle();
465 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
466 AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
467 FormatStyle::SIS_WithoutElse;
468 verifyFormat("if (a)\n"
469 " // comment\n"
470 " f();",
471 AllowsMergedIf);
472 verifyFormat("{\n"
473 " if (a)\n"
474 " label:\n"
475 " f();\n"
476 "}",
477 AllowsMergedIf);
478 verifyFormat("#define A \\\n"
479 " if (a) \\\n"
480 " label: \\\n"
481 " f()",
482 AllowsMergedIf);
483 verifyFormat("if (a)\n"
484 " ;",
485 AllowsMergedIf);
486 verifyFormat("if (a)\n"
487 " if (b) return;",
488 AllowsMergedIf);
489
490 verifyFormat("if (a) // Can't merge this\n"
491 " f();\n",
492 AllowsMergedIf);
493 verifyFormat("if (a) /* still don't merge */\n"
494 " f();",
495 AllowsMergedIf);
496 verifyFormat("if (a) { // Never merge this\n"
497 " f();\n"
498 "}",
499 AllowsMergedIf);
500 verifyFormat("if (a) { /* Never merge this */\n"
501 " f();\n"
502 "}",
503 AllowsMergedIf);
504
505 AllowsMergedIf.ColumnLimit = 14;
506 verifyFormat("if (a) return;", AllowsMergedIf);
507 verifyFormat("if (aaaaaaaaa)\n"
508 " return;",
509 AllowsMergedIf);
510
511 AllowsMergedIf.ColumnLimit = 13;
512 verifyFormat("if (a)\n return;", AllowsMergedIf);
513}
514
515TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
516 FormatStyle AllowsMergedIf = getLLVMStyle();
517 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
518 AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
519 FormatStyle::SIS_WithoutElse;
520 verifyFormat("if (a)\n"
521 " f();\n"
522 "else {\n"
523 " g();\n"
524 "}",
525 AllowsMergedIf);
526 verifyFormat("if (a)\n"
527 " f();\n"
528 "else\n"
529 " g();\n",
530 AllowsMergedIf);
531
532 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
533
534 verifyFormat("if (a) f();\n"
535 "else {\n"
536 " g();\n"
537 "}",
538 AllowsMergedIf);
539 verifyFormat("if (a) f();\n"
540 "else {\n"
541 " if (a) f();\n"
542 " else {\n"
543 " g();\n"
544 " }\n"
545 " g();\n"
546 "}",
547 AllowsMergedIf);
548}
549
550TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
551 FormatStyle AllowsMergedLoops = getLLVMStyle();
552 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
553 verifyFormat("while (true) continue;", AllowsMergedLoops);
554 verifyFormat("for (;;) continue;", AllowsMergedLoops);
555 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
556 verifyFormat("while (true)\n"
557 " ;",
558 AllowsMergedLoops);
559 verifyFormat("for (;;)\n"
560 " ;",
561 AllowsMergedLoops);
562 verifyFormat("for (;;)\n"
563 " for (;;) continue;",
564 AllowsMergedLoops);
565 verifyFormat("for (;;) // Can't merge this\n"
566 " continue;",
567 AllowsMergedLoops);
568 verifyFormat("for (;;) /* still don't merge */\n"
569 " continue;",
570 AllowsMergedLoops);
571 verifyFormat("do a++;\n"
572 "while (true);",
573 AllowsMergedLoops);
574 verifyFormat("do /* Don't merge */\n"
575 " a++;\n"
576 "while (true);",
577 AllowsMergedLoops);
578 verifyFormat("do // Don't merge\n"
579 " a++;\n"
580 "while (true);",
581 AllowsMergedLoops);
582 verifyFormat("do\n"
583 " // Don't merge\n"
584 " a++;\n"
585 "while (true);",
586 AllowsMergedLoops);
587 // Without braces labels are interpreted differently.
588 verifyFormat("{\n"
589 " do\n"
590 " label:\n"
591 " a++;\n"
592 " while (true);\n"
593 "}",
594 AllowsMergedLoops);
595}
596
597TEST_F(FormatTest, FormatShortBracedStatements) {
598 FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
599 AllowSimpleBracedStatements.ColumnLimit = 40;
600 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
601 FormatStyle::SBS_Always;
602
603 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
604 FormatStyle::SIS_WithoutElse;
605 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
606
607 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
608 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
609 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
610
611 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
612 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
613 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
614 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
615 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
616 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
617 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
618 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
619 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
620 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
621 verifyFormat("if (true) { fffffffffffffffffffffff(); }",
622 AllowSimpleBracedStatements);
623 verifyFormat("if (true) {\n"
624 " ffffffffffffffffffffffff();\n"
625 "}",
626 AllowSimpleBracedStatements);
627 verifyFormat("if (true) {\n"
628 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
629 "}",
630 AllowSimpleBracedStatements);
631 verifyFormat("if (true) { //\n"
632 " f();\n"
633 "}",
634 AllowSimpleBracedStatements);
635 verifyFormat("if (true) {\n"
636 " f();\n"
637 " f();\n"
638 "}",
639 AllowSimpleBracedStatements);
640 verifyFormat("if (true) {\n"
641 " f();\n"
642 "} else {\n"
643 " f();\n"
644 "}",
645 AllowSimpleBracedStatements);
646
647 verifyFormat("struct A2 {\n"
648 " int X;\n"
649 "};",
650 AllowSimpleBracedStatements);
651 verifyFormat("typedef struct A2 {\n"
652 " int X;\n"
653 "} A2_t;",
654 AllowSimpleBracedStatements);
655 verifyFormat("template <int> struct A2 {\n"
656 " struct B {};\n"
657 "};",
658 AllowSimpleBracedStatements);
659
660 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
661 FormatStyle::SIS_Never;
662 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
663 verifyFormat("if (true) {\n"
664 " f();\n"
665 "}",
666 AllowSimpleBracedStatements);
667 verifyFormat("if (true) {\n"
668 " f();\n"
669 "} else {\n"
670 " f();\n"
671 "}",
672 AllowSimpleBracedStatements);
673
674 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
675 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
676 verifyFormat("while (true) {\n"
677 " f();\n"
678 "}",
679 AllowSimpleBracedStatements);
680 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
681 verifyFormat("for (;;) {\n"
682 " f();\n"
683 "}",
684 AllowSimpleBracedStatements);
685
686 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
687 FormatStyle::SIS_WithoutElse;
688 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
689 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
690 FormatStyle::BWACS_Always;
691
692 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
693 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
694 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
695 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
696 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
697 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
698 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
699 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
700 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
701 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
702 verifyFormat("if (true) { fffffffffffffffffffffff(); }",
703 AllowSimpleBracedStatements);
704 verifyFormat("if (true)\n"
705 "{\n"
706 " ffffffffffffffffffffffff();\n"
707 "}",
708 AllowSimpleBracedStatements);
709 verifyFormat("if (true)\n"
710 "{\n"
711 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
712 "}",
713 AllowSimpleBracedStatements);
714 verifyFormat("if (true)\n"
715 "{ //\n"
716 " f();\n"
717 "}",
718 AllowSimpleBracedStatements);
719 verifyFormat("if (true)\n"
720 "{\n"
721 " f();\n"
722 " f();\n"
723 "}",
724 AllowSimpleBracedStatements);
725 verifyFormat("if (true)\n"
726 "{\n"
727 " f();\n"
728 "} else\n"
729 "{\n"
730 " f();\n"
731 "}",
732 AllowSimpleBracedStatements);
733
734 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
735 FormatStyle::SIS_Never;
736 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
737 verifyFormat("if (true)\n"
738 "{\n"
739 " f();\n"
740 "}",
741 AllowSimpleBracedStatements);
742 verifyFormat("if (true)\n"
743 "{\n"
744 " f();\n"
745 "} else\n"
746 "{\n"
747 " f();\n"
748 "}",
749 AllowSimpleBracedStatements);
750
751 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
752 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
753 verifyFormat("while (true)\n"
754 "{\n"
755 " f();\n"
756 "}",
757 AllowSimpleBracedStatements);
758 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
759 verifyFormat("for (;;)\n"
760 "{\n"
761 " f();\n"
762 "}",
763 AllowSimpleBracedStatements);
764}
765
766TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
767 FormatStyle Style = getLLVMStyleWithColumns(60);
768 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
769 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
770 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
771 EXPECT_EQ("#define A \\\n"
772 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n"
773 " { \\\n"
774 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
775 " }\n"
776 "X;",
777 format("#define A \\\n"
778 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
779 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
780 " }\n"
781 "X;",
782 Style));
783}
784
785TEST_F(FormatTest, ParseIfElse) {
786 verifyFormat("if (true)\n"
787 " if (true)\n"
788 " if (true)\n"
789 " f();\n"
790 " else\n"
791 " g();\n"
792 " else\n"
793 " h();\n"
794 "else\n"
795 " i();");
796 verifyFormat("if (true)\n"
797 " if (true)\n"
798 " if (true) {\n"
799 " if (true)\n"
800 " f();\n"
801 " } else {\n"
802 " g();\n"
803 " }\n"
804 " else\n"
805 " h();\n"
806 "else {\n"
807 " i();\n"
808 "}");
809 verifyFormat("if (true)\n"
810 " if constexpr (true)\n"
811 " if (true) {\n"
812 " if constexpr (true)\n"
813 " f();\n"
814 " } else {\n"
815 " g();\n"
816 " }\n"
817 " else\n"
818 " h();\n"
819 "else {\n"
820 " i();\n"
821 "}");
822 verifyFormat("if (true)\n"
823 " if CONSTEXPR (true)\n"
824 " if (true) {\n"
825 " if CONSTEXPR (true)\n"
826 " f();\n"
827 " } else {\n"
828 " g();\n"
829 " }\n"
830 " else\n"
831 " h();\n"
832 "else {\n"
833 " i();\n"
834 "}");
835 verifyFormat("void f() {\n"
836 " if (a) {\n"
837 " } else {\n"
838 " }\n"
839 "}");
840}
841
842TEST_F(FormatTest, ElseIf) {
843 verifyFormat("if (a) {\n} else if (b) {\n}");
844 verifyFormat("if (a)\n"
845 " f();\n"
846 "else if (b)\n"
847 " g();\n"
848 "else\n"
849 " h();");
850 verifyFormat("if constexpr (a)\n"
851 " f();\n"
852 "else if constexpr (b)\n"
853 " g();\n"
854 "else\n"
855 " h();");
856 verifyFormat("if CONSTEXPR (a)\n"
857 " f();\n"
858 "else if CONSTEXPR (b)\n"
859 " g();\n"
860 "else\n"
861 " h();");
862 verifyFormat("if (a) {\n"
863 " f();\n"
864 "}\n"
865 "// or else ..\n"
866 "else {\n"
867 " g()\n"
868 "}");
869
870 verifyFormat("if (a) {\n"
871 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
873 "}");
874 verifyFormat("if (a) {\n"
875 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
877 "}");
878 verifyFormat("if (a) {\n"
879 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
881 "}");
882 verifyFormat("if (a) {\n"
883 "} else if (\n"
884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
885 "}",
886 getLLVMStyleWithColumns(62));
887 verifyFormat("if (a) {\n"
888 "} else if constexpr (\n"
889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
890 "}",
891 getLLVMStyleWithColumns(62));
892 verifyFormat("if (a) {\n"
893 "} else if CONSTEXPR (\n"
894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
895 "}",
896 getLLVMStyleWithColumns(62));
897}
898
899TEST_F(FormatTest, FormatsForLoop) {
900 verifyFormat(
901 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
902 " ++VeryVeryLongLoopVariable)\n"
903 " ;");
904 verifyFormat("for (;;)\n"
905 " f();");
906 verifyFormat("for (;;) {\n}");
907 verifyFormat("for (;;) {\n"
908 " f();\n"
909 "}");
910 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
911
912 verifyFormat(
913 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
914 " E = UnwrappedLines.end();\n"
915 " I != E; ++I) {\n}");
916
917 verifyFormat(
918 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
919 " ++IIIII) {\n}");
920 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
921 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
922 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
923 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
924 " I = FD->getDeclsInPrototypeScope().begin(),\n"
925 " E = FD->getDeclsInPrototypeScope().end();\n"
926 " I != E; ++I) {\n}");
927 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
928 " I = Container.begin(),\n"
929 " E = Container.end();\n"
930 " I != E; ++I) {\n}",
931 getLLVMStyleWithColumns(76));
932
933 verifyFormat(
934 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
938 " ++aaaaaaaaaaa) {\n}");
939 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
940 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
941 " ++i) {\n}");
942 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
943 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
944 "}");
945 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
946 " aaaaaaaaaa);\n"
947 " iter; ++iter) {\n"
948 "}");
949 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
950 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
951 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
952 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
953
954 // These should not be formatted as Objective-C for-in loops.
955 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
956 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
957 verifyFormat("Foo *x;\nfor (x in y) {\n}");
958 verifyFormat(
959 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
960
961 FormatStyle NoBinPacking = getLLVMStyle();
962 NoBinPacking.BinPackParameters = false;
963 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
964 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
965 " aaaaaaaaaaaaaaaa,\n"
966 " aaaaaaaaaaaaaaaa,\n"
967 " aaaaaaaaaaaaaaaa);\n"
968 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
969 "}",
970 NoBinPacking);
971 verifyFormat(
972 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
973 " E = UnwrappedLines.end();\n"
974 " I != E;\n"
975 " ++I) {\n}",
976 NoBinPacking);
977
978 FormatStyle AlignLeft = getLLVMStyle();
979 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
980 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
981}
982
983TEST_F(FormatTest, RangeBasedForLoops) {
984 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
986 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
987 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
988 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
990 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
991 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
992}
993
994TEST_F(FormatTest, ForEachLoops) {
995 verifyFormat("void f() {\n"
996 " foreach (Item *item, itemlist) {}\n"
997 " Q_FOREACH (Item *item, itemlist) {}\n"
998 " BOOST_FOREACH (Item *item, itemlist) {}\n"
999 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1000 "}");
1001
1002 FormatStyle Style = getLLVMStyle();
1003 Style.SpaceBeforeParens =
1004 FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
1005 verifyFormat("void f() {\n"
1006 " foreach(Item *item, itemlist) {}\n"
1007 " Q_FOREACH(Item *item, itemlist) {}\n"
1008 " BOOST_FOREACH(Item *item, itemlist) {}\n"
1009 " UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1010 "}",
1011 Style);
1012
1013 // As function-like macros.
1014 verifyFormat("#define foreach(x, y)\n"
1015 "#define Q_FOREACH(x, y)\n"
1016 "#define BOOST_FOREACH(x, y)\n"
1017 "#define UNKNOWN_FOREACH(x, y)\n");
1018
1019 // Not as function-like macros.
1020 verifyFormat("#define foreach (x, y)\n"
1021 "#define Q_FOREACH (x, y)\n"
1022 "#define BOOST_FOREACH (x, y)\n"
1023 "#define UNKNOWN_FOREACH (x, y)\n");
1024
1025 // handle microsoft non standard extension
1026 verifyFormat("for each (char c in x->MyStringProperty)");
1027}
1028
1029TEST_F(FormatTest, FormatsWhileLoop) {
1030 verifyFormat("while (true) {\n}");
1031 verifyFormat("while (true)\n"
1032 " f();");
1033 verifyFormat("while () {\n}");
1034 verifyFormat("while () {\n"
1035 " f();\n"
1036 "}");
1037}
1038
1039TEST_F(FormatTest, FormatsDoWhile) {
1040 verifyFormat("do {\n"
1041 " do_something();\n"
1042 "} while (something());");
1043 verifyFormat("do\n"
1044 " do_something();\n"
1045 "while (something());");
1046}
1047
1048TEST_F(FormatTest, FormatsSwitchStatement) {
1049 verifyFormat("switch (x) {\n"
1050 "case 1:\n"
1051 " f();\n"
1052 " break;\n"
1053 "case kFoo:\n"
1054 "case ns::kBar:\n"
1055 "case kBaz:\n"
1056 " break;\n"
1057 "default:\n"
1058 " g();\n"
1059 " break;\n"
1060 "}");
1061 verifyFormat("switch (x) {\n"
1062 "case 1: {\n"
1063 " f();\n"
1064 " break;\n"
1065 "}\n"
1066 "case 2: {\n"
1067 " break;\n"
1068 "}\n"
1069 "}");
1070 verifyFormat("switch (x) {\n"
1071 "case 1: {\n"
1072 " f();\n"
1073 " {\n"
1074 " g();\n"
1075 " h();\n"
1076 " }\n"
1077 " break;\n"
1078 "}\n"
1079 "}");
1080 verifyFormat("switch (x) {\n"
1081 "case 1: {\n"
1082 " f();\n"
1083 " if (foo) {\n"
1084 " g();\n"
1085 " h();\n"
1086 " }\n"
1087 " break;\n"
1088 "}\n"
1089 "}");
1090 verifyFormat("switch (x) {\n"
1091 "case 1: {\n"
1092 " f();\n"
1093 " g();\n"
1094 "} break;\n"
1095 "}");
1096 verifyFormat("switch (test)\n"
1097 " ;");
1098 verifyFormat("switch (x) {\n"
1099 "default: {\n"
1100 " // Do nothing.\n"
1101 "}\n"
1102 "}");
1103 verifyFormat("switch (x) {\n"
1104 "// comment\n"
1105 "// if 1, do f()\n"
1106 "case 1:\n"
1107 " f();\n"
1108 "}");
1109 verifyFormat("switch (x) {\n"
1110 "case 1:\n"
1111 " // Do amazing stuff\n"
1112 " {\n"
1113 " f();\n"
1114 " g();\n"
1115 " }\n"
1116 " break;\n"
1117 "}");
1118 verifyFormat("#define A \\\n"
1119 " switch (x) { \\\n"
1120 " case a: \\\n"
1121 " foo = b; \\\n"
1122 " }",
1123 getLLVMStyleWithColumns(20));
1124 verifyFormat("#define OPERATION_CASE(name) \\\n"
1125 " case OP_name: \\\n"
1126 " return operations::Operation##name\n",
1127 getLLVMStyleWithColumns(40));
1128 verifyFormat("switch (x) {\n"
1129 "case 1:;\n"
1130 "default:;\n"
1131 " int i;\n"
1132 "}");
1133
1134 verifyGoogleFormat("switch (x) {\n"
1135 " case 1:\n"
1136 " f();\n"
1137 " break;\n"
1138 " case kFoo:\n"
1139 " case ns::kBar:\n"
1140 " case kBaz:\n"
1141 " break;\n"
1142 " default:\n"
1143 " g();\n"
1144 " break;\n"
1145 "}");
1146 verifyGoogleFormat("switch (x) {\n"
1147 " case 1: {\n"
1148 " f();\n"
1149 " break;\n"
1150 " }\n"
1151 "}");
1152 verifyGoogleFormat("switch (test)\n"
1153 " ;");
1154
1155 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1156 " case OP_name: \\\n"
1157 " return operations::Operation##name\n");
1158 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1159 " // Get the correction operation class.\n"
1160 " switch (OpCode) {\n"
1161 " CASE(Add);\n"
1162 " CASE(Subtract);\n"
1163 " default:\n"
1164 " return operations::Unknown;\n"
1165 " }\n"
1166 "#undef OPERATION_CASE\n"
1167 "}");
1168 verifyFormat("DEBUG({\n"
1169 " switch (x) {\n"
1170 " case A:\n"
1171 " f();\n"
1172 " break;\n"
1173 " // fallthrough\n"
1174 " case B:\n"
1175 " g();\n"
1176 " break;\n"
1177 " }\n"
1178 "});");
1179 EXPECT_EQ("DEBUG({\n"
1180 " switch (x) {\n"
1181 " case A:\n"
1182 " f();\n"
1183 " break;\n"
1184 " // On B:\n"
1185 " case B:\n"
1186 " g();\n"
1187 " break;\n"
1188 " }\n"
1189 "});",
1190 format("DEBUG({\n"
1191 " switch (x) {\n"
1192 " case A:\n"
1193 " f();\n"
1194 " break;\n"
1195 " // On B:\n"
1196 " case B:\n"
1197 " g();\n"
1198 " break;\n"
1199 " }\n"
1200 "});",
1201 getLLVMStyle()));
1202 EXPECT_EQ("switch (n) {\n"
1203 "case 0: {\n"
1204 " return false;\n"
1205 "}\n"
1206 "default: {\n"
1207 " return true;\n"
1208 "}\n"
1209 "}",
1210 format("switch (n)\n"
1211 "{\n"
1212 "case 0: {\n"
1213 " return false;\n"
1214 "}\n"
1215 "default: {\n"
1216 " return true;\n"
1217 "}\n"
1218 "}",
1219 getLLVMStyle()));
1220 verifyFormat("switch (a) {\n"
1221 "case (b):\n"
1222 " return;\n"
1223 "}");
1224
1225 verifyFormat("switch (a) {\n"
1226 "case some_namespace::\n"
1227 " some_constant:\n"
1228 " return;\n"
1229 "}",
1230 getLLVMStyleWithColumns(34));
1231
1232 FormatStyle Style = getLLVMStyle();
1233 Style.IndentCaseLabels = true;
1234 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1235 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1236 Style.BraceWrapping.AfterCaseLabel = true;
1237 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1238 EXPECT_EQ("switch (n)\n"
1239 "{\n"
1240 " case 0:\n"
1241 " {\n"
1242 " return false;\n"
1243 " }\n"
1244 " default:\n"
1245 " {\n"
1246 " return true;\n"
1247 " }\n"
1248 "}",
1249 format("switch (n) {\n"
1250 " case 0: {\n"
1251 " return false;\n"
1252 " }\n"
1253 " default: {\n"
1254 " return true;\n"
1255 " }\n"
1256 "}",
1257 Style));
1258 Style.BraceWrapping.AfterCaseLabel = false;
1259 EXPECT_EQ("switch (n)\n"
1260 "{\n"
1261 " case 0: {\n"
1262 " return false;\n"
1263 " }\n"
1264 " default: {\n"
1265 " return true;\n"
1266 " }\n"
1267 "}",
1268 format("switch (n) {\n"
1269 " case 0:\n"
1270 " {\n"
1271 " return false;\n"
1272 " }\n"
1273 " default:\n"
1274 " {\n"
1275 " return true;\n"
1276 " }\n"
1277 "}",
1278 Style));
1279 Style.IndentCaseLabels = false;
1280 Style.IndentCaseBlocks = true;
1281 EXPECT_EQ("switch (n)\n"
1282 "{\n"
1283 "case 0:\n"
1284 " {\n"
1285 " return false;\n"
1286 " }\n"
1287 "case 1:\n"
1288 " break;\n"
1289 "default:\n"
1290 " {\n"
1291 " return true;\n"
1292 " }\n"
1293 "}",
1294 format("switch (n) {\n"
1295 "case 0: {\n"
1296 " return false;\n"
1297 "}\n"
1298 "case 1:\n"
1299 " break;\n"
1300 "default: {\n"
1301 " return true;\n"
1302 "}\n"
1303 "}",
1304 Style));
1305 Style.IndentCaseLabels = true;
1306 Style.IndentCaseBlocks = true;
1307 EXPECT_EQ("switch (n)\n"
1308 "{\n"
1309 " case 0:\n"
1310 " {\n"
1311 " return false;\n"
1312 " }\n"
1313 " case 1:\n"
1314 " break;\n"
1315 " default:\n"
1316 " {\n"
1317 " return true;\n"
1318 " }\n"
1319 "}",
1320 format("switch (n) {\n"
1321 "case 0: {\n"
1322 " return false;\n"
1323 "}\n"
1324 "case 1:\n"
1325 " break;\n"
1326 "default: {\n"
1327 " return true;\n"
1328 "}\n"
1329 "}",
1330 Style));
1331}
1332
1333TEST_F(FormatTest, CaseRanges) {
1334 verifyFormat("switch (x) {\n"
1335 "case 'A' ... 'Z':\n"
1336 "case 1 ... 5:\n"
1337 "case a ... b:\n"
1338 " break;\n"
1339 "}");
1340}
1341
1342TEST_F(FormatTest, ShortEnums) {
1343 FormatStyle Style = getLLVMStyle();
1344 Style.AllowShortEnumsOnASingleLine = true;
1345 verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1346 Style.AllowShortEnumsOnASingleLine = false;
1347 verifyFormat("enum\n"
1348 "{\n"
1349 " A,\n"
1350 " B,\n"
1351 " C\n"
1352 "} ShortEnum1, ShortEnum2;",
1353 Style);
1354}
1355
1356TEST_F(FormatTest, ShortCaseLabels) {
1357 FormatStyle Style = getLLVMStyle();
1358 Style.AllowShortCaseLabelsOnASingleLine = true;
1359 verifyFormat("switch (a) {\n"
1360 "case 1: x = 1; break;\n"
1361 "case 2: return;\n"
1362 "case 3:\n"
1363 "case 4:\n"
1364 "case 5: return;\n"
1365 "case 6: // comment\n"
1366 " return;\n"
1367 "case 7:\n"
1368 " // comment\n"
1369 " return;\n"
1370 "case 8:\n"
1371 " x = 8; // comment\n"
1372 " break;\n"
1373 "default: y = 1; break;\n"
1374 "}",
1375 Style);
1376 verifyFormat("switch (a) {\n"
1377 "case 0: return; // comment\n"
1378 "case 1: break; // comment\n"
1379 "case 2: return;\n"
1380 "// comment\n"
1381 "case 3: return;\n"
1382 "// comment 1\n"
1383 "// comment 2\n"
1384 "// comment 3\n"
1385 "case 4: break; /* comment */\n"
1386 "case 5:\n"
1387 " // comment\n"
1388 " break;\n"
1389 "case 6: /* comment */ x = 1; break;\n"
1390 "case 7: x = /* comment */ 1; break;\n"
1391 "case 8:\n"
1392 " x = 1; /* comment */\n"
1393 " break;\n"
1394 "case 9:\n"
1395 " break; // comment line 1\n"
1396 " // comment line 2\n"
1397 "}",
1398 Style);
1399 EXPECT_EQ("switch (a) {\n"
1400 "case 1:\n"
1401 " x = 8;\n"
1402 " // fall through\n"
1403 "case 2: x = 8;\n"
1404 "// comment\n"
1405 "case 3:\n"
1406 " return; /* comment line 1\n"
1407 " * comment line 2 */\n"
1408 "case 4: i = 8;\n"
1409 "// something else\n"
1410 "#if FOO\n"
1411 "case 5: break;\n"
1412 "#endif\n"
1413 "}",
1414 format("switch (a) {\n"
1415 "case 1: x = 8;\n"
1416 " // fall through\n"
1417 "case 2:\n"
1418 " x = 8;\n"
1419 "// comment\n"
1420 "case 3:\n"
1421 " return; /* comment line 1\n"
1422 " * comment line 2 */\n"
1423 "case 4:\n"
1424 " i = 8;\n"
1425 "// something else\n"
1426 "#if FOO\n"
1427 "case 5: break;\n"
1428 "#endif\n"
1429 "}",
1430 Style));
1431 EXPECT_EQ("switch (a) {\n"
1432 "case 0:\n"
1433 " return; // long long long long long long long long long long "
1434 "long long comment\n"
1435 " // line\n"
1436 "}",
1437 format("switch (a) {\n"
1438 "case 0: return; // long long long long long long long long "
1439 "long long long long comment line\n"
1440 "}",
1441 Style));
1442 EXPECT_EQ("switch (a) {\n"
1443 "case 0:\n"
1444 " return; /* long long long long long long long long long long "
1445 "long long comment\n"
1446 " line */\n"
1447 "}",
1448 format("switch (a) {\n"
1449 "case 0: return; /* long long long long long long long long "
1450 "long long long long comment line */\n"
1451 "}",
1452 Style));
1453 verifyFormat("switch (a) {\n"
1454 "#if FOO\n"
1455 "case 0: return 0;\n"
1456 "#endif\n"
1457 "}",
1458 Style);
1459 verifyFormat("switch (a) {\n"
1460 "case 1: {\n"
1461 "}\n"
1462 "case 2: {\n"
1463 " return;\n"
1464 "}\n"
1465 "case 3: {\n"
1466 " x = 1;\n"
1467 " return;\n"
1468 "}\n"
1469 "case 4:\n"
1470 " if (x)\n"
1471 " return;\n"
1472 "}",
1473 Style);
1474 Style.ColumnLimit = 21;
1475 verifyFormat("switch (a) {\n"
1476 "case 1: x = 1; break;\n"
1477 "case 2: return;\n"
1478 "case 3:\n"
1479 "case 4:\n"
1480 "case 5: return;\n"
1481 "default:\n"
1482 " y = 1;\n"
1483 " break;\n"
1484 "}",
1485 Style);
1486 Style.ColumnLimit = 80;
1487 Style.AllowShortCaseLabelsOnASingleLine = false;
1488 Style.IndentCaseLabels = true;
1489 EXPECT_EQ("switch (n) {\n"
1490 " default /*comments*/:\n"
1491 " return true;\n"
1492 " case 0:\n"
1493 " return false;\n"
1494 "}",
1495 format("switch (n) {\n"
1496 "default/*comments*/:\n"
1497 " return true;\n"
1498 "case 0:\n"
1499 " return false;\n"
1500 "}",
1501 Style));
1502 Style.AllowShortCaseLabelsOnASingleLine = true;
1503 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1504 Style.BraceWrapping.AfterCaseLabel = true;
1505 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1506 EXPECT_EQ("switch (n)\n"
1507 "{\n"
1508 " case 0:\n"
1509 " {\n"
1510 " return false;\n"
1511 " }\n"
1512 " default:\n"
1513 " {\n"
1514 " return true;\n"
1515 " }\n"
1516 "}",
1517 format("switch (n) {\n"
1518 " case 0: {\n"
1519 " return false;\n"
1520 " }\n"
1521 " default:\n"
1522 " {\n"
1523 " return true;\n"
1524 " }\n"
1525 "}",
1526 Style));
1527}
1528
1529TEST_F(FormatTest, FormatsLabels) {
1530 verifyFormat("void f() {\n"
1531 " some_code();\n"
1532 "test_label:\n"
1533 " some_other_code();\n"
1534 " {\n"
1535 " some_more_code();\n"
1536 " another_label:\n"
1537 " some_more_code();\n"
1538 " }\n"
1539 "}");
1540 verifyFormat("{\n"
1541 " some_code();\n"
1542 "test_label:\n"
1543 " some_other_code();\n"
1544 "}");
1545 verifyFormat("{\n"
1546 " some_code();\n"
1547 "test_label:;\n"
1548 " int i = 0;\n"
1549 "}");
1550 FormatStyle Style = getLLVMStyle();
1551 Style.IndentGotoLabels = false;
1552 verifyFormat("void f() {\n"
1553 " some_code();\n"
1554 "test_label:\n"
1555 " some_other_code();\n"
1556 " {\n"
1557 " some_more_code();\n"
1558 "another_label:\n"
1559 " some_more_code();\n"
1560 " }\n"
1561 "}",
1562 Style);
1563 verifyFormat("{\n"
1564 " some_code();\n"
1565 "test_label:\n"
1566 " some_other_code();\n"
1567 "}",
1568 Style);
1569 verifyFormat("{\n"
1570 " some_code();\n"
1571 "test_label:;\n"
1572 " int i = 0;\n"
1573 "}");
1574}
1575
1576TEST_F(FormatTest, MultiLineControlStatements) {
1577 FormatStyle Style = getLLVMStyle();
1578 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1579 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1580 Style.ColumnLimit = 20;
1581 // Short lines should keep opening brace on same line.
1582 EXPECT_EQ("if (foo) {\n"
1583 " bar();\n"
1584 "}",
1585 format("if(foo){bar();}", Style));
1586 EXPECT_EQ("if (foo) {\n"
1587 " bar();\n"
1588 "} else {\n"
1589 " baz();\n"
1590 "}",
1591 format("if(foo){bar();}else{baz();}", Style));
1592 EXPECT_EQ("if (foo && bar) {\n"
1593 " baz();\n"
1594 "}",
1595 format("if(foo&&bar){baz();}", Style));
1596 EXPECT_EQ("if (foo) {\n"
1597 " bar();\n"
1598 "} else if (baz) {\n"
1599 " quux();\n"
1600 "}",
1601 format("if(foo){bar();}else if(baz){quux();}", Style));
1602 EXPECT_EQ(
1603 "if (foo) {\n"
1604 " bar();\n"
1605 "} else if (baz) {\n"
1606 " quux();\n"
1607 "} else {\n"
1608 " foobar();\n"
1609 "}",
1610 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1611 EXPECT_EQ("for (;;) {\n"
1612 " foo();\n"
1613 "}",
1614 format("for(;;){foo();}"));
1615 EXPECT_EQ("while (1) {\n"
1616 " foo();\n"
1617 "}",
1618 format("while(1){foo();}", Style));
1619 EXPECT_EQ("switch (foo) {\n"
1620 "case bar:\n"
1621 " return;\n"
1622 "}",
1623 format("switch(foo){case bar:return;}", Style));
1624 EXPECT_EQ("try {\n"
1625 " foo();\n"
1626 "} catch (...) {\n"
1627 " bar();\n"
1628 "}",
1629 format("try{foo();}catch(...){bar();}", Style));
1630 EXPECT_EQ("do {\n"
1631 " foo();\n"
1632 "} while (bar &&\n"
1633 " baz);",
1634 format("do{foo();}while(bar&&baz);", Style));
1635 // Long lines should put opening brace on new line.
1636 EXPECT_EQ("if (foo && bar &&\n"
1637 " baz)\n"
1638 "{\n"
1639 " quux();\n"
1640 "}",
1641 format("if(foo&&bar&&baz){quux();}", Style));
1642 EXPECT_EQ("if (foo && bar &&\n"
1643 " baz)\n"
1644 "{\n"
1645 " quux();\n"
1646 "}",
1647 format("if (foo && bar &&\n"
1648 " baz) {\n"
1649 " quux();\n"
1650 "}",
1651 Style));
1652 EXPECT_EQ("if (foo) {\n"
1653 " bar();\n"
1654 "} else if (baz ||\n"
1655 " quux)\n"
1656 "{\n"
1657 " foobar();\n"
1658 "}",
1659 format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1660 EXPECT_EQ(
1661 "if (foo) {\n"
1662 " bar();\n"
1663 "} else if (baz ||\n"
1664 " quux)\n"
1665 "{\n"
1666 " foobar();\n"
1667 "} else {\n"
1668 " barbaz();\n"
1669 "}",
1670 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1671 Style));
1672 EXPECT_EQ("for (int i = 0;\n"
1673 " i < 10; ++i)\n"
1674 "{\n"
1675 " foo();\n"
1676 "}",
1677 format("for(int i=0;i<10;++i){foo();}", Style));
1678 EXPECT_EQ("foreach (int i,\n"
1679 " list)\n"
1680 "{\n"
1681 " foo();\n"
1682 "}",
1683 format("foreach(int i, list){foo();}", Style));
1684 Style.ColumnLimit =
1685 40; // to concentrate at brace wrapping, not line wrap due to column limit
1686 EXPECT_EQ("foreach (int i, list) {\n"
1687 " foo();\n"
1688 "}",
1689 format("foreach(int i, list){foo();}", Style));
1690 Style.ColumnLimit =
1691 20; // to concentrate at brace wrapping, not line wrap due to column limit
1692 EXPECT_EQ("while (foo || bar ||\n"
1693 " baz)\n"
1694 "{\n"
1695 " quux();\n"
1696 "}",
1697 format("while(foo||bar||baz){quux();}", Style));
1698 EXPECT_EQ("switch (\n"
1699 " foo = barbaz)\n"
1700 "{\n"
1701 "case quux:\n"
1702 " return;\n"
1703 "}",
1704 format("switch(foo=barbaz){case quux:return;}", Style));
1705 EXPECT_EQ("try {\n"
1706 " foo();\n"
1707 "} catch (\n"
1708 " Exception &bar)\n"
1709 "{\n"
1710 " baz();\n"
1711 "}",
1712 format("try{foo();}catch(Exception&bar){baz();}", Style));
1713 Style.ColumnLimit =
1714 40; // to concentrate at brace wrapping, not line wrap due to column limit
1715 EXPECT_EQ("try {\n"
1716 " foo();\n"
1717 "} catch (Exception &bar) {\n"
1718 " baz();\n"
1719 "}",
1720 format("try{foo();}catch(Exception&bar){baz();}", Style));
1721 Style.ColumnLimit =
1722 20; // to concentrate at brace wrapping, not line wrap due to column limit
1723
1724 Style.BraceWrapping.BeforeElse = true;
1725 EXPECT_EQ(
1726 "if (foo) {\n"
1727 " bar();\n"
1728 "}\n"
1729 "else if (baz ||\n"
1730 " quux)\n"
1731 "{\n"
1732 " foobar();\n"
1733 "}\n"
1734 "else {\n"
1735 " barbaz();\n"
1736 "}",
1737 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1738 Style));
1739
1740 Style.BraceWrapping.BeforeCatch = true;
1741 EXPECT_EQ("try {\n"
1742 " foo();\n"
1743 "}\n"
1744 "catch (...) {\n"
1745 " baz();\n"
1746 "}",
1747 format("try{foo();}catch(...){baz();}", Style));
1748}
1749
1750TEST_F(FormatTest, BeforeWhile) {
1751 FormatStyle Style = getLLVMStyle();
1752 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1753
1754 verifyFormat("do {\n"
1755 " foo();\n"
1756 "} while (1);",
1757 Style);
1758 Style.BraceWrapping.BeforeWhile = true;
1759 verifyFormat("do {\n"
1760 " foo();\n"
1761 "}\n"
1762 "while (1);",
1763 Style);
1764}
1765
1766//===----------------------------------------------------------------------===//
1767// Tests for classes, namespaces, etc.
1768//===----------------------------------------------------------------------===//
1769
1770TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1771 verifyFormat("class A {};");
1772}
1773
1774TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1775 verifyFormat("class A {\n"
1776 "public:\n"
1777 "public: // comment\n"
1778 "protected:\n"
1779 "private:\n"
1780 " void f() {}\n"
1781 "};");
1782 verifyFormat("export class A {\n"
1783 "public:\n"
1784 "public: // comment\n"
1785 "protected:\n"
1786 "private:\n"
1787 " void f() {}\n"
1788 "};");
1789 verifyGoogleFormat("class A {\n"
1790 " public:\n"
1791 " protected:\n"
1792 " private:\n"
1793 " void f() {}\n"
1794 "};");
1795 verifyGoogleFormat("export class A {\n"
1796 " public:\n"
1797 " protected:\n"
1798 " private:\n"
1799 " void f() {}\n"
1800 "};");
1801 verifyFormat("class A {\n"
1802 "public slots:\n"
1803 " void f1() {}\n"
1804 "public Q_SLOTS:\n"
1805 " void f2() {}\n"
1806 "protected slots:\n"
1807 " void f3() {}\n"
1808 "protected Q_SLOTS:\n"
1809 " void f4() {}\n"
1810 "private slots:\n"
1811 " void f5() {}\n"
1812 "private Q_SLOTS:\n"
1813 " void f6() {}\n"
1814 "signals:\n"
1815 " void g1();\n"
1816 "Q_SIGNALS:\n"
1817 " void g2();\n"
1818 "};");
1819
1820 // Don't interpret 'signals' the wrong way.
1821 verifyFormat("signals.set();");
1822 verifyFormat("for (Signals signals : f()) {\n}");
1823 verifyFormat("{\n"
1824 " signals.set(); // This needs indentation.\n"
1825 "}");
1826 verifyFormat("void f() {\n"
1827 "label:\n"
1828 " signals.baz();\n"
1829 "}");
1830}
1831
1832TEST_F(FormatTest, SeparatesLogicalBlocks) {
1833 EXPECT_EQ("class A {\n"
1834 "public:\n"
1835 " void f();\n"
1836 "\n"
1837 "private:\n"
1838 " void g() {}\n"
1839 " // test\n"
1840 "protected:\n"
1841 " int h;\n"
1842 "};",
1843 format("class A {\n"
1844 "public:\n"
1845 "void f();\n"
1846 "private:\n"
1847 "void g() {}\n"
1848 "// test\n"
1849 "protected:\n"
1850 "int h;\n"
1851 "};"));
1852 EXPECT_EQ("class A {\n"
1853 "protected:\n"
1854 "public:\n"
1855 " void f();\n"
1856 "};",
1857 format("class A {\n"
1858 "protected:\n"
1859 "\n"
1860 "public:\n"
1861 "\n"
1862 " void f();\n"
1863 "};"));
1864
1865 // Even ensure proper spacing inside macros.
1866 EXPECT_EQ("#define B \\\n"
1867 " class A { \\\n"
1868 " protected: \\\n"
1869 " public: \\\n"
1870 " void f(); \\\n"
1871 " };",
1872 format("#define B \\\n"
1873 " class A { \\\n"
1874 " protected: \\\n"
1875 " \\\n"
1876 " public: \\\n"
1877 " \\\n"
1878 " void f(); \\\n"
1879 " };",
1880 getGoogleStyle()));
1881 // But don't remove empty lines after macros ending in access specifiers.
1882 EXPECT_EQ("#define A private:\n"
1883 "\n"
1884 "int i;",
1885 format("#define A private:\n"
1886 "\n"
1887 "int i;"));
1888}
1889
1890TEST_F(FormatTest, FormatsClasses) {
1891 verifyFormat("class A : public B {};");
1892 verifyFormat("class A : public ::B {};");
1893
1894 verifyFormat(
1895 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1896 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1897 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1898 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1899 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1900 verifyFormat(
1901 "class A : public B, public C, public D, public E, public F {};");
1902 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1903 " public C,\n"
1904 " public D,\n"
1905 " public E,\n"
1906 " public F,\n"
1907 " public G {};");
1908
1909 verifyFormat("class\n"
1910 " ReallyReallyLongClassName {\n"
1911 " int i;\n"
1912 "};",
1913 getLLVMStyleWithColumns(32));
1914 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1915 " aaaaaaaaaaaaaaaa> {};");
1916 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1917 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1918 " aaaaaaaaaaaaaaaaaaaaaa> {};");
1919 verifyFormat("template <class R, class C>\n"
1920 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1921 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1922 verifyFormat("class ::A::B {};");
1923}
1924
1925TEST_F(FormatTest, BreakInheritanceStyle) {
1926 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1927 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1928 FormatStyle::BILS_BeforeComma;
1929 verifyFormat("class MyClass : public X {};",
1930 StyleWithInheritanceBreakBeforeComma);
1931 verifyFormat("class MyClass\n"
1932 " : public X\n"
1933 " , public Y {};",
1934 StyleWithInheritanceBreakBeforeComma);
1935 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1936 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1937 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1938 StyleWithInheritanceBreakBeforeComma);
1939 verifyFormat("struct aaaaaaaaaaaaa\n"
1940 " : public aaaaaaaaaaaaaaaaaaa< // break\n"
1941 " aaaaaaaaaaaaaaaa> {};",
1942 StyleWithInheritanceBreakBeforeComma);
1943
1944 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1945 StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1946 FormatStyle::BILS_AfterColon;
1947 verifyFormat("class MyClass : public X {};",
1948 StyleWithInheritanceBreakAfterColon);
1949 verifyFormat("class MyClass : public X, public Y {};",
1950 StyleWithInheritanceBreakAfterColon);
1951 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1952 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1953 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1954 StyleWithInheritanceBreakAfterColon);
1955 verifyFormat("struct aaaaaaaaaaaaa :\n"
1956 " public aaaaaaaaaaaaaaaaaaa< // break\n"
1957 " aaaaaaaaaaaaaaaa> {};",
1958 StyleWithInheritanceBreakAfterColon);
1959}
1960
1961TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1962 verifyFormat("class A {\n} a, b;");
1963 verifyFormat("struct A {\n} a, b;");
1964 verifyFormat("union A {\n} a;");
1965}
1966
1967TEST_F(FormatTest, FormatsEnum) {
1968 verifyFormat("enum {\n"
1969 " Zero,\n"
1970 " One = 1,\n"
1971 " Two = One + 1,\n"
1972 " Three = (One + Two),\n"
1973 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1974 " Five = (One, Two, Three, Four, 5)\n"
1975 "};");
1976 verifyGoogleFormat("enum {\n"
1977 " Zero,\n"
1978 " One = 1,\n"
1979 " Two = One + 1,\n"
1980 " Three = (One + Two),\n"
1981 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
1982 " Five = (One, Two, Three, Four, 5)\n"
1983 "};");
1984 verifyFormat("enum Enum {};");
1985 verifyFormat("enum {};");
1986 verifyFormat("enum X E {} d;");
1987 verifyFormat("enum __attribute__((...)) E {} d;");
1988 verifyFormat("enum __declspec__((...)) E {} d;");
1989 verifyFormat("enum {\n"
1990 " Bar = Foo<int, int>::value\n"
1991 "};",
1992 getLLVMStyleWithColumns(30));
1993
1994 verifyFormat("enum ShortEnum { A, B, C };");
1995 verifyGoogleFormat("enum ShortEnum { A, B, C };");
1996
1997 EXPECT_EQ("enum KeepEmptyLines {\n"
1998 " ONE,\n"
1999 "\n"
2000 " TWO,\n"
2001 "\n"
2002 " THREE\n"
2003 "}",
2004 format("enum KeepEmptyLines {\n"
2005 " ONE,\n"
2006 "\n"
2007 " TWO,\n"
2008 "\n"
2009 "\n"
2010 " THREE\n"
2011 "}"));
2012 verifyFormat("enum E { // comment\n"
2013 " ONE,\n"
2014 " TWO\n"
2015 "};\n"
2016 "int i;");
2017
2018 FormatStyle EightIndent = getLLVMStyle();
2019 EightIndent.IndentWidth = 8;
2020 verifyFormat("enum {\n"
2021 " VOID,\n"
2022 " CHAR,\n"
2023 " SHORT,\n"
2024 " INT,\n"
2025 " LONG,\n"
2026 " SIGNED,\n"
2027 " UNSIGNED,\n"
2028 " BOOL,\n"
2029 " FLOAT,\n"
2030 " DOUBLE,\n"
2031 " COMPLEX\n"
2032 "};",
2033 EightIndent);
2034
2035 // Not enums.
2036 verifyFormat("enum X f() {\n"
2037 " a();\n"
2038 " return 42;\n"
2039 "}");
2040 verifyFormat("enum X Type::f() {\n"
2041 " a();\n"
2042 " return 42;\n"
2043 "}");
2044 verifyFormat("enum ::X f() {\n"
2045 " a();\n"
2046 " return 42;\n"
2047 "}");
2048 verifyFormat("enum ns::X f() {\n"
2049 " a();\n"
2050 " return 42;\n"
2051 "}");
2052}
2053
2054TEST_F(FormatTest, FormatsEnumsWithErrors) {
2055 verifyFormat("enum Type {\n"
2056 " One = 0; // These semicolons should be commas.\n"
2057 " Two = 1;\n"
2058 "};");
2059 verifyFormat("namespace n {\n"
2060 "enum Type {\n"
2061 " One,\n"
2062 " Two, // missing };\n"
2063 " int i;\n"
2064 "}\n"
2065 "void g() {}");
2066}
2067
2068TEST_F(FormatTest, FormatsEnumStruct) {
2069 verifyFormat("enum struct {\n"
2070 " Zero,\n"
2071 " One = 1,\n"
2072 " Two = One + 1,\n"
2073 " Three = (One + Two),\n"
2074 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
2075 " Five = (One, Two, Three, Four, 5)\n"
2076 "};");
2077 verifyFormat("enum struct Enum {};");
2078 verifyFormat("enum struct {};");
2079 verifyFormat("enum struct X E {} d;");
2080 verifyFormat("enum struct __attribute__((...)) E {} d;");
2081 verifyFormat("enum struct __declspec__((...)) E {} d;");
2082 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
2083}
2084
2085TEST_F(FormatTest, FormatsEnumClass) {
2086 verifyFormat("enum class {\n"
2087 " Zero,\n"
2088 " One = 1,\n"
2089 " Two = One + 1,\n"
2090 " Three = (One + Two),\n"
2091 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
2092 " Five = (One, Two, Three, Four, 5)\n"
2093 "};");
2094 verifyFormat("enum class Enum {};");
2095 verifyFormat("enum class {};");
2096 verifyFormat("enum class X E {} d;");
2097 verifyFormat("enum class __attribute__((...)) E {} d;");
2098 verifyFormat("enum class __declspec__((...)) E {} d;");
2099 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
2100}
2101
2102TEST_F(FormatTest, FormatsEnumTypes) {
2103 verifyFormat("enum X : int {\n"
2104 " A, // Force multiple lines.\n"
2105 " B\n"
2106 "};");
2107 verifyFormat("enum X : int { A, B };");
2108 verifyFormat("enum X : std::uint32_t { A, B };");
2109}
2110
2111TEST_F(FormatTest, FormatsTypedefEnum) {
2112 FormatStyle Style = getLLVMStyle();
2113 Style.ColumnLimit = 40;
2114 verifyFormat("typedef enum {} EmptyEnum;");
2115 verifyFormat("typedef enum { A, B, C } ShortEnum;");
2116 verifyFormat("typedef enum {\n"
2117 " ZERO = 0,\n"
2118 " ONE = 1,\n"
2119 " TWO = 2,\n"
2120 " THREE = 3\n"
2121 "} LongEnum;",
2122 Style);
2123 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2124 Style.BraceWrapping.AfterEnum = true;
2125 verifyFormat("typedef enum {} EmptyEnum;");
2126 verifyFormat("typedef enum { A, B, C } ShortEnum;");
2127 verifyFormat("typedef enum\n"
2128 "{\n"
2129 " ZERO = 0,\n"
2130 " ONE = 1,\n"
2131 " TWO = 2,\n"
2132 " THREE = 3\n"
2133 "} LongEnum;",
2134 Style);
2135}
2136
2137TEST_F(FormatTest, FormatsNSEnums) {
2138 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2139 verifyGoogleFormat(
2140 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2141 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2142 " // Information about someDecentlyLongValue.\n"
2143 " someDecentlyLongValue,\n"
2144 " // Information about anotherDecentlyLongValue.\n"
2145 " anotherDecentlyLongValue,\n"
2146 " // Information about aThirdDecentlyLongValue.\n"
2147 " aThirdDecentlyLongValue\n"
2148 "};");
2149 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2150 " // Information about someDecentlyLongValue.\n"
2151 " someDecentlyLongValue,\n"
2152 " // Information about anotherDecentlyLongValue.\n"
2153 " anotherDecentlyLongValue,\n"
2154 " // Information about aThirdDecentlyLongValue.\n"
2155 " aThirdDecentlyLongValue\n"
2156 "};");
2157 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2158 " a = 1,\n"
2159 " b = 2,\n"
2160 " c = 3,\n"
2161 "};");
2162 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2163 " a = 1,\n"
2164 " b = 2,\n"
2165 " c = 3,\n"
2166 "};");
2167 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2168 " a = 1,\n"
2169 " b = 2,\n"
2170 " c = 3,\n"
2171 "};");
2172 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2173 " a = 1,\n"
2174 " b = 2,\n"
2175 " c = 3,\n"
2176 "};");
2177}
2178
2179TEST_F(FormatTest, FormatsBitfields) {
2180 verifyFormat("struct Bitfields {\n"
2181 " unsigned sClass : 8;\n"
2182 " unsigned ValueKind : 2;\n"
2183 "};");
2184 verifyFormat("struct A {\n"
2185 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2186 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2187 "};");
2188 verifyFormat("struct MyStruct {\n"
2189 " uchar data;\n"
2190 " uchar : 8;\n"
2191 " uchar : 8;\n"
2192 " uchar other;\n"
2193 "};");
2194 FormatStyle Style = getLLVMStyle();
2195 Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
2196 verifyFormat("struct Bitfields {\n"
2197 " unsigned sClass:8;\n"
2198 " unsigned ValueKind:2;\n"
2199 " uchar other;\n"
2200 "};",
2201 Style);
2202 verifyFormat("struct A {\n"
2203 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
2204 " bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
2205 "};",
2206 Style);
2207 Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
2208 verifyFormat("struct Bitfields {\n"
2209 " unsigned sClass :8;\n"
2210 " unsigned ValueKind :2;\n"
2211 " uchar other;\n"
2212 "};",
2213 Style);
2214 Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
2215 verifyFormat("struct Bitfields {\n"
2216 " unsigned sClass: 8;\n"
2217 " unsigned ValueKind: 2;\n"
2218 " uchar other;\n"
2219 "};",
2220 Style);
2221}
2222
2223TEST_F(FormatTest, FormatsNamespaces) {
2224 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2225 LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2226
2227 verifyFormat("namespace some_namespace {\n"
2228 "class A {};\n"
2229 "void f() { f(); }\n"
2230 "}",
2231 LLVMWithNoNamespaceFix);
2232 verifyFormat("namespace N::inline D {\n"
2233 "class A {};\n"
2234 "void f() { f(); }\n"
2235 "}",
2236 LLVMWithNoNamespaceFix);
2237 verifyFormat("namespace N::inline D::E {\n"
2238 "class A {};\n"
2239 "void f() { f(); }\n"
2240 "}",
2241 LLVMWithNoNamespaceFix);
2242 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2243 "class A {};\n"
2244 "void f() { f(); }\n"
2245 "}",
2246 LLVMWithNoNamespaceFix);
2247 verifyFormat("/* something */ namespace some_namespace {\n"
2248 "class A {};\n"
2249 "void f() { f(); }\n"
2250 "}",
2251 LLVMWithNoNamespaceFix);
2252 verifyFormat("namespace {\n"
2253 "class A {};\n"
2254 "void f() { f(); }\n"
2255 "}",
2256 LLVMWithNoNamespaceFix);
2257 verifyFormat("/* something */ namespace {\n"
2258 "class A {};\n"
2259 "void f() { f(); }\n"
2260 "}",
2261 LLVMWithNoNamespaceFix);
2262 verifyFormat("inline namespace X {\n"
2263 "class A {};\n"
2264 "void f() { f(); }\n"
2265 "}",
2266 LLVMWithNoNamespaceFix);
2267 verifyFormat("/* something */ inline namespace X {\n"
2268 "class A {};\n"
2269 "void f() { f(); }\n"
2270 "}",
2271 LLVMWithNoNamespaceFix);
2272 verifyFormat("export namespace X {\n"
2273 "class A {};\n"
2274 "void f() { f(); }\n"
2275 "}",
2276 LLVMWithNoNamespaceFix);
2277 verifyFormat("using namespace some_namespace;\n"
2278 "class A {};\n"
2279 "void f() { f(); }",
2280 LLVMWithNoNamespaceFix);
2281
2282 // This code is more common than we thought; if we
2283 // layout this correctly the semicolon will go into
2284 // its own line, which is undesirable.
2285 verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2286 verifyFormat("namespace {\n"
2287 "class A {};\n"
2288 "};",
2289 LLVMWithNoNamespaceFix);
2290
2291 verifyFormat("namespace {\n"
2292 "int SomeVariable = 0; // comment\n"
2293 "} // namespace",
2294 LLVMWithNoNamespaceFix);
2295 EXPECT_EQ("#ifndef HEADER_GUARD\n"
2296 "#define HEADER_GUARD\n"
2297 "namespace my_namespace {\n"
2298 "int i;\n"
2299 "} // my_namespace\n"
2300 "#endif // HEADER_GUARD",
2301 format("#ifndef HEADER_GUARD\n"
2302 " #define HEADER_GUARD\n"
2303 " namespace my_namespace {\n"
2304 "int i;\n"
2305 "} // my_namespace\n"
2306 "#endif // HEADER_GUARD",
2307 LLVMWithNoNamespaceFix));
2308
2309 EXPECT_EQ("namespace A::B {\n"
2310 "class C {};\n"
2311 "}",
2312 format("namespace A::B {\n"
2313 "class C {};\n"
2314 "}",
2315 LLVMWithNoNamespaceFix));
2316
2317 FormatStyle Style = getLLVMStyle();
2318 Style.NamespaceIndentation = FormatStyle::NI_All;
2319 EXPECT_EQ("namespace out {\n"
2320 " int i;\n"
2321 " namespace in {\n"
2322 " int i;\n"
2323 " } // namespace in\n"
2324 "} // namespace out",
2325 format("namespace out {\n"
2326 "int i;\n"
2327 "namespace in {\n"
2328 "int i;\n"
2329 "} // namespace in\n"
2330 "} // namespace out",
2331 Style));
2332
2333 Style.NamespaceIndentation = FormatStyle::NI_Inner;
2334 EXPECT_EQ("namespace out {\n"
2335 "int i;\n"
2336 "namespace in {\n"
2337 " int i;\n"
2338 "} // namespace in\n"
2339 "} // namespace out",
2340 format("namespace out {\n"
2341 "int i;\n"
2342 "namespace in {\n"
2343 "int i;\n"
2344 "} // namespace in\n"
2345 "} // namespace out",
2346 Style));
2347}
2348
2349TEST_F(FormatTest, NamespaceMacros) {
2350 FormatStyle Style = getLLVMStyle();
2351 Style.NamespaceMacros.push_back("TESTSUITE");
2352
2353 verifyFormat("TESTSUITE(A) {\n"
2354 "int foo();\n"
2355 "} // TESTSUITE(A)",
2356 Style);
2357
2358 verifyFormat("TESTSUITE(A, B) {\n"
2359 "int foo();\n"
2360 "} // TESTSUITE(A)",
2361 Style);
2362
2363 // Properly indent according to NamespaceIndentation style
2364 Style.NamespaceIndentation = FormatStyle::NI_All;
2365 verifyFormat("TESTSUITE(A) {\n"
2366 " int foo();\n"
2367 "} // TESTSUITE(A)",
2368 Style);
2369 verifyFormat("TESTSUITE(A) {\n"
2370 " namespace B {\n"
2371 " int foo();\n"
2372 " } // namespace B\n"
2373 "} // TESTSUITE(A)",
2374 Style);
2375 verifyFormat("namespace A {\n"
2376 " TESTSUITE(B) {\n"
2377 " int foo();\n"
2378 " } // TESTSUITE(B)\n"
2379 "} // namespace A",
2380 Style);
2381
2382 Style.NamespaceIndentation = FormatStyle::NI_Inner;
2383 verifyFormat("TESTSUITE(A) {\n"
2384 "TESTSUITE(B) {\n"
2385 " int foo();\n"
2386 "} // TESTSUITE(B)\n"
2387 "} // TESTSUITE(A)",
2388 Style);
2389 verifyFormat("TESTSUITE(A) {\n"
2390 "namespace B {\n"
2391 " int foo();\n"
2392 "} // namespace B\n"
2393 "} // TESTSUITE(A)",
2394 Style);
2395 verifyFormat("namespace A {\n"
2396 "TESTSUITE(B) {\n"
2397 " int foo();\n"
2398 "} // TESTSUITE(B)\n"
2399 "} // namespace A",
2400 Style);
2401
2402 // Properly merge namespace-macros blocks in CompactNamespaces mode
2403 Style.NamespaceIndentation = FormatStyle::NI_None;
2404 Style.CompactNamespaces = true;
2405 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2406 "}} // TESTSUITE(A::B)",
2407 Style);
2408
2409 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2410 "}} // TESTSUITE(out::in)",
2411 format("TESTSUITE(out) {\n"
2412 "TESTSUITE(in) {\n"
2413 "} // TESTSUITE(in)\n"
2414 "} // TESTSUITE(out)",
2415 Style));
2416
2417 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2418 "}} // TESTSUITE(out::in)",
2419 format("TESTSUITE(out) {\n"
2420 "TESTSUITE(in) {\n"
2421 "} // TESTSUITE(in)\n"
2422 "} // TESTSUITE(out)",
2423 Style));
2424
2425 // Do not merge different namespaces/macros
2426 EXPECT_EQ("namespace out {\n"
2427 "TESTSUITE(in) {\n"
2428 "} // TESTSUITE(in)\n"
2429 "} // namespace out",
2430 format("namespace out {\n"
2431 "TESTSUITE(in) {\n"
2432 "} // TESTSUITE(in)\n"
2433 "} // namespace out",
2434 Style));
2435 EXPECT_EQ("TESTSUITE(out) {\n"
2436 "namespace in {\n"
2437 "} // namespace in\n"
2438 "} // TESTSUITE(out)",
2439 format("TESTSUITE(out) {\n"
2440 "namespace in {\n"
2441 "} // namespace in\n"
2442 "} // TESTSUITE(out)",
2443 Style));
2444 Style.NamespaceMacros.push_back("FOOBAR");
2445 EXPECT_EQ("TESTSUITE(out) {\n"
2446 "FOOBAR(in) {\n"
2447 "} // FOOBAR(in)\n"
2448 "} // TESTSUITE(out)",
2449 format("TESTSUITE(out) {\n"
2450 "FOOBAR(in) {\n"
2451 "} // FOOBAR(in)\n"
2452 "} // TESTSUITE(out)",
2453 Style));
2454}
2455
2456TEST_F(FormatTest, FormatsCompactNamespaces) {
2457 FormatStyle Style = getLLVMStyle();
2458 Style.CompactNamespaces = true;
2459 Style.NamespaceMacros.push_back("TESTSUITE");
2460
2461 verifyFormat("namespace A { namespace B {\n"
2462 "}} // namespace A::B",
2463 Style);
2464
2465 EXPECT_EQ("namespace out { namespace in {\n"
2466 "}} // namespace out::in",
2467 format("namespace out {\n"
2468 "namespace in {\n"
2469 "} // namespace in\n"
2470 "} // namespace out",
2471 Style));
2472
2473 // Only namespaces which have both consecutive opening and end get compacted
2474 EXPECT_EQ("namespace out {\n"
2475 "namespace in1 {\n"
2476 "} // namespace in1\n"
2477 "namespace in2 {\n"
2478 "} // namespace in2\n"
2479 "} // namespace out",
2480 format("namespace out {\n"
2481 "namespace in1 {\n"
2482 "} // namespace in1\n"
2483 "namespace in2 {\n"
2484 "} // namespace in2\n"
2485 "} // namespace out",
2486 Style));
2487
2488 EXPECT_EQ("namespace out {\n"
2489 "int i;\n"
2490 "namespace in {\n"
2491 "int j;\n"
2492 "} // namespace in\n"
2493 "int k;\n"
2494 "} // namespace out",
2495 format("namespace out { int i;\n"
2496 "namespace in { int j; } // namespace in\n"
2497 "int k; } // namespace out",
2498 Style));
2499
2500 EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2501 "}}} // namespace A::B::C\n",
2502 format("namespace A { namespace B {\n"
2503 "namespace C {\n"
2504 "}} // namespace B::C\n"
2505 "} // namespace A\n",
2506 Style));
2507
2508 Style.ColumnLimit = 40;
2509 EXPECT_EQ("namespace aaaaaaaaaa {\n"
2510 "namespace bbbbbbbbbb {\n"
2511 "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2512 format("namespace aaaaaaaaaa {\n"
2513 "namespace bbbbbbbbbb {\n"
2514 "} // namespace bbbbbbbbbb\n"
2515 "} // namespace aaaaaaaaaa",
2516 Style));
2517
2518 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2519 "namespace cccccc {\n"
2520 "}}} // namespace aaaaaa::bbbbbb::cccccc",
2521 format("namespace aaaaaa {\n"
2522 "namespace bbbbbb {\n"
2523 "namespace cccccc {\n"
2524 "} // namespace cccccc\n"
2525 "} // namespace bbbbbb\n"
2526 "} // namespace aaaaaa",
2527 Style));
2528 Style.ColumnLimit = 80;
2529
2530 // Extra semicolon after 'inner' closing brace prevents merging
2531 EXPECT_EQ("namespace out { namespace in {\n"
2532 "}; } // namespace out::in",
2533 format("namespace out {\n"
2534 "namespace in {\n"
2535 "}; // namespace in\n"
2536 "} // namespace out",
2537 Style));
2538
2539 // Extra semicolon after 'outer' closing brace is conserved
2540 EXPECT_EQ("namespace out { namespace in {\n"
2541 "}}; // namespace out::in",
2542 format("namespace out {\n"
2543 "namespace in {\n"
2544 "} // namespace in\n"
2545 "}; // namespace out",
2546 Style));
2547
2548 Style.NamespaceIndentation = FormatStyle::NI_All;
2549 EXPECT_EQ("namespace out { namespace in {\n"
2550 " int i;\n"
2551 "}} // namespace out::in",
2552 format("namespace out {\n"
2553 "namespace in {\n"
2554 "int i;\n"
2555 "} // namespace in\n"
2556 "} // namespace out",
2557 Style));
2558 EXPECT_EQ("namespace out { namespace mid {\n"
2559 " namespace in {\n"
2560 " int j;\n"
2561 " } // namespace in\n"
2562 " int k;\n"
2563 "}} // namespace out::mid",
2564 format("namespace out { namespace mid {\n"
2565 "namespace in { int j; } // namespace in\n"
2566 "int k; }} // namespace out::mid",
2567 Style));
2568
2569 Style.NamespaceIndentation = FormatStyle::NI_Inner;
2570 EXPECT_EQ("namespace out { namespace in {\n"
2571 " int i;\n"
2572 "}} // namespace out::in",
2573 format("namespace out {\n"
2574 "namespace in {\n"
2575 "int i;\n"
2576 "} // namespace in\n"
2577 "} // namespace out",
2578 Style));
2579 EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2580 " int i;\n"
2581 "}}} // namespace out::mid::in",
2582 format("namespace out {\n"
2583 "namespace mid {\n"
2584 "namespace in {\n"
2585 "int i;\n"
2586 "} // namespace in\n"
2587 "} // namespace mid\n"
2588 "} // namespace out",
2589 Style));
2590}
2591
2592TEST_F(FormatTest, FormatsExternC) {
2593 verifyFormat("extern \"C\" {\nint a;");
2594 verifyFormat("extern \"C\" {}");
2595 verifyFormat("extern \"C\" {\n"
2596 "int foo();\n"
2597 "}");
2598 verifyFormat("extern \"C\" int foo() {}");
2599 verifyFormat("extern \"C\" int foo();");
2600 verifyFormat("extern \"C\" int foo() {\n"
2601 " int i = 42;\n"
2602 " return i;\n"
2603 "}");
2604
2605 FormatStyle Style = getLLVMStyle();
2606 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2607 Style.BraceWrapping.AfterFunction = true;
2608 verifyFormat("extern \"C\" int foo() {}", Style);
2609 verifyFormat("extern \"C\" int foo();", Style);
2610 verifyFormat("extern \"C\" int foo()\n"
2611 "{\n"
2612 " int i = 42;\n"
2613 " return i;\n"
2614 "}",
2615 Style);
2616
2617 Style.BraceWrapping.AfterExternBlock = true;
2618 Style.BraceWrapping.SplitEmptyRecord = false;
2619 verifyFormat("extern \"C\"\n"
2620 "{}",
2621 Style);
2622 verifyFormat("extern \"C\"\n"
2623 "{\n"
2624 " int foo();\n"
2625 "}",
2626 Style);
2627}
2628
2629TEST_F(FormatTest, IndentExternBlockStyle) {
2630 FormatStyle Style = getLLVMStyle();
2631 Style.IndentWidth = 2;
2632
2633 Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2634 verifyFormat("extern \"C\" { /*9*/\n}", Style);
2635 verifyFormat("extern \"C\" {\n"
2636 " int foo10();\n"
2637 "}",
2638 Style);
2639
2640 Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2641 verifyFormat("extern \"C\" { /*11*/\n}", Style);
2642 verifyFormat("extern \"C\" {\n"
2643 "int foo12();\n"
2644 "}",
2645 Style);
2646
2647 Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2648 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2649 Style.BraceWrapping.AfterExternBlock = true;
2650 verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2651 verifyFormat("extern \"C\"\n{\n"
2652 " int foo14();\n"
2653 "}",
2654 Style);
2655
2656 Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2657 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2658 Style.BraceWrapping.AfterExternBlock = false;
2659 verifyFormat("extern \"C\" { /*15*/\n}", Style);
2660 verifyFormat("extern \"C\" {\n"
2661 "int foo16();\n"
2662 "}",
2663 Style);
2664}
2665
2666TEST_F(FormatTest, FormatsInlineASM) {
2667 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2668 verifyFormat("asm(\"nop\" ::: \"memory\");");
2669 verifyFormat(
2670 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2671 " \"cpuid\\n\\t\"\n"
2672 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2673 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2674 " : \"a\"(value));");
2675 EXPECT_EQ(
2676 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2677 " __asm {\n"
2678 " mov edx,[that] // vtable in edx\n"
2679 " mov eax,methodIndex\n"
2680 " call [edx][eax*4] // stdcall\n"
2681 " }\n"
2682 "}",
2683 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2684 " __asm {\n"
2685 " mov edx,[that] // vtable in edx\n"
2686 " mov eax,methodIndex\n"
2687 " call [edx][eax*4] // stdcall\n"
2688 " }\n"
2689 "}"));
2690 EXPECT_EQ("_asm {\n"
2691 " xor eax, eax;\n"
2692 " cpuid;\n"
2693 "}",
2694 format("_asm {\n"
2695 " xor eax, eax;\n"
2696 " cpuid;\n"
2697 "}"));
2698 verifyFormat("void function() {\n"
2699 " // comment\n"
2700 " asm(\"\");\n"
2701 "}");
2702 EXPECT_EQ("__asm {\n"
2703 "}\n"
2704 "int i;",
2705 format("__asm {\n"
2706 "}\n"
2707 "int i;"));
2708}
2709
2710TEST_F(FormatTest, FormatTryCatch) {
2711 verifyFormat("try {\n"
2712 " throw a * b;\n"
2713 "} catch (int a) {\n"
2714 " // Do nothing.\n"
2715 "} catch (...) {\n"
2716 " exit(42);\n"
2717 "}");
2718
2719 // Function-level try statements.
2720 verifyFormat("int f() try { return 4; } catch (...) {\n"
2721 " return 5;\n"
2722 "}");
2723 verifyFormat("class A {\n"
2724 " int a;\n"
2725 " A() try : a(0) {\n"
2726 " } catch (...) {\n"
2727 " throw;\n"
2728 " }\n"
2729 "};\n");
2730 verifyFormat("class A {\n"
2731 " int a;\n"
2732 " A() try : a(0), b{1} {\n"
2733 " } catch (...) {\n"
2734 " throw;\n"
2735 " }\n"
2736 "};\n");
2737 verifyFormat("class A {\n"
2738 " int a;\n"
2739 " A() try : a(0), b{1}, c{2} {\n"
2740 " } catch (...) {\n"
2741 " throw;\n"
2742 " }\n"
2743 "};\n");
2744 verifyFormat("class A {\n"
2745 " int a;\n"
2746 " A() try : a(0), b{1}, c{2} {\n"
2747 " { // New scope.\n"
2748 " }\n"
2749 " } catch (...) {\n"
2750 " throw;\n"
2751 " }\n"
2752 "};\n");
2753
2754 // Incomplete try-catch blocks.
2755 verifyIncompleteFormat("try {} catch (");
2756}
2757
2758TEST_F(FormatTest, FormatTryAsAVariable) {
2759 verifyFormat("int try;");
2760 verifyFormat("int try, size;");
2761 verifyFormat("try = foo();");
2762 verifyFormat("if (try < size) {\n return true;\n}");
2763
2764 verifyFormat("int catch;");
2765 verifyFormat("int catch, size;");
2766 verifyFormat("catch = foo();");
2767 verifyFormat("if (catch < size) {\n return true;\n}");
2768
2769 FormatStyle Style = getLLVMStyle();
2770 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2771 Style.BraceWrapping.AfterFunction = true;
2772 Style.BraceWrapping.BeforeCatch = true;
2773 verifyFormat("try {\n"
2774 " int bar = 1;\n"
2775 "}\n"
2776 "catch (...) {\n"
2777 " int bar = 1;\n"
2778 "}",
2779 Style);
2780 verifyFormat("#if NO_EX\n"
2781 "try\n"
2782 "#endif\n"
2783 "{\n"
2784 "}\n"
2785 "#if NO_EX\n"
2786 "catch (...) {\n"
2787 "}",
2788 Style);
2789 verifyFormat("try /* abc */ {\n"
2790 " int bar = 1;\n"
2791 "}\n"
2792 "catch (...) {\n"
2793 " int bar = 1;\n"
2794 "}",
2795 Style);
2796 verifyFormat("try\n"
2797 "// abc\n"
2798 "{\n"
2799 " int bar = 1;\n"
2800 "}\n"
2801 "catch (...) {\n"
2802 " int bar = 1;\n"
2803 "}",
2804 Style);
2805}
2806
2807TEST_F(FormatTest, FormatSEHTryCatch) {
2808 verifyFormat("__try {\n"
2809 " int a = b * c;\n"
2810 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2811 " // Do nothing.\n"
2812 "}");
2813
2814 verifyFormat("__try {\n"
2815 " int a = b * c;\n"
2816 "} __finally {\n"
2817 " // Do nothing.\n"
2818 "}");
2819
2820 verifyFormat("DEBUG({\n"
2821 " __try {\n"
2822 " } __finally {\n"
2823 " }\n"
2824 "});\n");
2825}
2826
2827TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2828 verifyFormat("try {\n"
2829 " f();\n"
2830 "} catch {\n"
2831 " g();\n"
2832 "}");
2833 verifyFormat("try {\n"
2834 " f();\n"
2835 "} catch (A a) MACRO(x) {\n"
2836 " g();\n"
2837 "} catch (B b) MACRO(x) {\n"
2838 " g();\n"
2839 "}");
2840}
2841
2842TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2843 FormatStyle Style = getLLVMStyle();
2844 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2845 FormatStyle::BS_WebKit}) {
2846 Style.BreakBeforeBraces = BraceStyle;
2847 verifyFormat("try {\n"
2848 " // something\n"
2849 "} catch (...) {\n"
2850 " // something\n"
2851 "}",
2852 Style);
2853 }
2854 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2855 verifyFormat("try {\n"
2856 " // something\n"
2857 "}\n"
2858 "catch (...) {\n"
2859 " // something\n"
2860 "}",
2861 Style);
2862 verifyFormat("__try {\n"
2863 " // something\n"
2864 "}\n"
2865 "__finally {\n"
2866 " // something\n"
2867 "}",
2868 Style);
2869 verifyFormat("@try {\n"
2870 " // something\n"
2871 "}\n"
2872 "@finally {\n"
2873 " // something\n"
2874 "}",
2875 Style);
2876 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2877 verifyFormat("try\n"
2878 "{\n"
2879 " // something\n"
2880 "}\n"
2881 "catch (...)\n"
2882 "{\n"
2883 " // something\n"
2884 "}",
2885 Style);
2886 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2887 verifyFormat("try\n"
2888 " {\n"
2889 " // something white\n"
2890 " }\n"
2891 "catch (...)\n"
2892 " {\n"
2893 " // something white\n"
2894 " }",
2895 Style);
2896 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2897 verifyFormat("try\n"
2898 " {\n"
2899 " // something\n"
2900 " }\n"
2901 "catch (...)\n"
2902 " {\n"
2903 " // something\n"
2904 " }",
2905 Style);
2906 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2907 Style.BraceWrapping.BeforeCatch = true;
2908 verifyFormat("try {\n"
2909 " // something\n"
2910 "}\n"
2911 "catch (...) {\n"
2912 " // something\n"
2913 "}",
2914 Style);
2915}
2916
2917TEST_F(FormatTest, StaticInitializers) {
2918 verifyFormat("static SomeClass SC = {1, 'a'};");
2919
2920 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2921 " 100000000, "
2922 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2923
2924 // Here, everything other than the "}" would fit on a line.
2925 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2926 " 10000000000000000000000000};");
2927 EXPECT_EQ("S s = {a,\n"
2928 "\n"
2929 " b};",
2930 format("S s = {\n"
2931 " a,\n"
2932 "\n"
2933 " b\n"
2934 "};"));
2935
2936 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2937 // line. However, the formatting looks a bit off and this probably doesn't
2938 // happen often in practice.
2939 verifyFormat("static int Variable[1] = {\n"
2940 " {1000000000000000000000000000000000000}};",
2941 getLLVMStyleWithColumns(40));
2942}
2943
2944TEST_F(FormatTest, DesignatedInitializers) {
2945 verifyFormat("const struct A a = {.a = 1, .b = 2};");
2946 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2947 " .bbbbbbbbbb = 2,\n"
2948 " .cccccccccc = 3,\n"
2949 " .dddddddddd = 4,\n"
2950 " .eeeeeeeeee = 5};");
2951 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2952 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2953 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2954 " .ccccccccccccccccccccccccccc = 3,\n"
2955 " .ddddddddddddddddddddddddddd = 4,\n"
2956 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2957
2958 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2959
2960 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2961 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2962 " [2] = bbbbbbbbbb,\n"
2963 " [3] = cccccccccc,\n"
2964 " [4] = dddddddddd,\n"
2965 " [5] = eeeeeeeeee};");
2966 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2967 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2968 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2969 " [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2970 " [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2971 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2972}
2973
2974TEST_F(FormatTest, NestedStaticInitializers) {
2975 verifyFormat("static A x = {{{}}};\n");
2976 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2977 " {init1, init2, init3, init4}}};",
2978 getLLVMStyleWithColumns(50));
2979
2980 verifyFormat("somes Status::global_reps[3] = {\n"
2981 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2982 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2983 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2984 getLLVMStyleWithColumns(60));
2985 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2986 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2987 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2988 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2989 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2990 " {rect.fRight - rect.fLeft, rect.fBottom - "
2991 "rect.fTop}};");
2992
2993 verifyFormat(
2994 "SomeArrayOfSomeType a = {\n"
2995 " {{1, 2, 3},\n"
2996 " {1, 2, 3},\n"
2997 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
2998 " 333333333333333333333333333333},\n"
2999 " {1, 2, 3},\n"
3000 " {1, 2, 3}}};");
3001 verifyFormat(
3002 "SomeArrayOfSomeType a = {\n"
3003 " {{1, 2, 3}},\n"
3004 " {{1, 2, 3}},\n"
3005 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
3006 " 333333333333333333333333333333}},\n"
3007 " {{1, 2, 3}},\n"
3008 " {{1, 2, 3}}};");
3009
3010 verifyFormat("struct {\n"
3011 " unsigned bit;\n"
3012 " const char *const name;\n"
3013 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
3014 " {kOsWin, \"Windows\"},\n"
3015 " {kOsLinux, \"Linux\"},\n"
3016 " {kOsCrOS, \"Chrome OS\"}};");
3017 verifyFormat("struct {\n"
3018 " unsigned bit;\n"
3019 " const char *const name;\n"
3020 "} kBitsToOs[] = {\n"
3021 " {kOsMac, \"Mac\"},\n"
3022 " {kOsWin, \"Windows\"},\n"
3023 " {kOsLinux, \"Linux\"},\n"
3024 " {kOsCrOS, \"Chrome OS\"},\n"
3025 "};");
3026}
3027
3028TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
3029 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3030 " \\\n"
3031 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
3032}
3033
3034TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
3035 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
3036 " OwningPtr<FileOutputBuffer> &buffer) = 0;");
3037
3038 // Do break defaulted and deleted functions.
3039 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3040 " default;",
3041 getLLVMStyleWithColumns(40));
3042 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3043 " delete;",
3044 getLLVMStyleWithColumns(40));
3045}
3046
3047TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
3048 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
3049 getLLVMStyleWithColumns(40));
3050 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3051 getLLVMStyleWithColumns(40));
3052 EXPECT_EQ("#define Q \\\n"
3053 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
3054 " \"aaaaaaaa.cpp\"",
3055 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3056 getLLVMStyleWithColumns(40)));
3057}
3058
3059TEST_F(FormatTest, UnderstandsLinePPDirective) {
3060 EXPECT_EQ("# 123 \"A string literal\"",
3061 format(" # 123 \"A string literal\""));
3062}
3063
3064TEST_F(FormatTest, LayoutUnknownPPDirective) {
3065 EXPECT_EQ("#;", format("#;"));
3066 verifyFormat("#\n;\n;\n;");
3067}
3068
3069TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
3070 EXPECT_EQ("#line 42 \"test\"\n",
3071 format("# \\\n line \\\n 42 \\\n \"test\"\n"));
3072 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n",
3073 getLLVMStyleWithColumns(12)));
3074}
3075
3076TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3077 EXPECT_EQ("#line 42 \"test\"",
3078 format("# \\\n line \\\n 42 \\\n \"test\""));
3079 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));
3080}
3081
3082TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3083 verifyFormat("#define A \\x20");
3084 verifyFormat("#define A \\ x20");
3085 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));
3086 verifyFormat("#define A ''");
3087 verifyFormat("#define A ''qqq");
3088 verifyFormat("#define A `qqq");
3089 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3090 EXPECT_EQ("const char *c = STRINGIFY(\n"
3091 "\\na : b);",
3092 format("const char * c = STRINGIFY(\n"
3093 "\\na : b);"));
3094
3095 verifyFormat("a\r\\");
3096 verifyFormat("a\v\\");
3097 verifyFormat("a\f\\");
3098}
3099
3100TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3101 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3102 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
3103 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
3104 // FIXME: We never break before the macro name.
3105 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
3106
3107 verifyFormat("#define A A\n#define A A");
3108 verifyFormat("#define A(X) A\n#define A A");
3109
3110 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3111 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
3112}
3113
3114TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3115 EXPECT_EQ("// somecomment\n"
3116 "#include \"a.h\"\n"
3117 "#define A( \\\n"
3118 " A, B)\n"
3119 "#include \"b.h\"\n"
3120 "// somecomment\n",
3121 format(" // somecomment\n"
3122 " #include \"a.h\"\n"
3123 "#define A(A,\\\n"
3124 " B)\n"
3125 " #include \"b.h\"\n"
3126 " // somecomment\n",
3127 getLLVMStyleWithColumns(13)));
3128}
3129
3130TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3131
3132TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3133 EXPECT_EQ("#define A \\\n"
3134 " c; \\\n"
3135 " e;\n"
3136 "f;",
3137 format("#define A c; e;\n"
3138 "f;",
3139 getLLVMStyleWithColumns(14)));
3140}
3141
3142TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3143
3144TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3145 EXPECT_EQ("int x,\n"
3146 "#define A\n"
3147 " y;",
3148 format("int x,\n#define A\ny;"));
3149}
3150
3151TEST_F(FormatTest, HashInMacroDefinition) {
3152 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3153 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
3154 verifyFormat("#define A \\\n"
3155 " { \\\n"
3156 " f(#c); \\\n"
3157 " }",
3158 getLLVMStyleWithColumns(11));
3159
3160 verifyFormat("#define A(X) \\\n"
3161 " void function##X()",
3162 getLLVMStyleWithColumns(22));
3163
3164 verifyFormat("#define A(a, b, c) \\\n"
3165 " void a##b##c()",
3166 getLLVMStyleWithColumns(22));
3167
3168 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3169}
3170
3171TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3172 EXPECT_EQ("#define A (x)", format("#define A (x)"));
3173 EXPECT_EQ("#define A(x)", format("#define A(x)"));
3174
3175 FormatStyle Style = getLLVMStyle();
3176 Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3177 verifyFormat("#define true ((foo)1)", Style);
3178 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3179 verifyFormat("#define false((foo)0)", Style);
3180}
3181
3182TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3183 EXPECT_EQ("#define A b;", format("#define A \\\n"
3184 " \\\n"
3185 " b;",
3186 getLLVMStyleWithColumns(25)));
3187 EXPECT_EQ("#define A \\\n"
3188 " \\\n"
3189 " a; \\\n"
3190 " b;",
3191 format("#define A \\\n"
3192 " \\\n"
3193 " a; \\\n"
3194 " b;",
3195 getLLVMStyleWithColumns(11)));
3196 EXPECT_EQ("#define A \\\n"
3197 " a; \\\n"
3198 " \\\n"
3199 " b;",
3200 format("#define A \\\n"
3201 " a; \\\n"
3202 " \\\n"
3203 " b;",
3204 getLLVMStyleWithColumns(11)));
3205}
3206
3207TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3208 verifyIncompleteFormat("#define A :");
3209 verifyFormat("#define SOMECASES \\\n"
3210 " case 1: \\\n"
3211 " case 2\n",
3212 getLLVMStyleWithColumns(20));
3213 verifyFormat("#define MACRO(a) \\\n"
3214 " if (a) \\\n"
3215 " f(); \\\n"
3216 " else \\\n"
3217 " g()",
3218 getLLVMStyleWithColumns(18));
3219 verifyFormat("#define A template <typename T>");
3220 verifyIncompleteFormat("#define STR(x) #x\n"
3221 "f(STR(this_is_a_string_literal{));");
3222 verifyFormat("#pragma omp threadprivate( \\\n"
3223 " y)), // expected-warning",
3224 getLLVMStyleWithColumns(28));
3225 verifyFormat("#d, = };");
3226 verifyFormat("#if \"a");
3227 verifyIncompleteFormat("({\n"
3228 "#define b \\\n"
3229 " } \\\n"
3230 " a\n"
3231 "a",
3232 getLLVMStyleWithColumns(15));
3233 verifyFormat("#define A \\\n"
3234 " { \\\n"
3235 " {\n"
3236 "#define B \\\n"
3237 " } \\\n"
3238 " }",
3239 getLLVMStyleWithColumns(15));
3240 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3241 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3242 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3243 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
3244}
3245
3246TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3247 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3248 EXPECT_EQ("class A : public QObject {\n"
3249 " Q_OBJECT\n"
3250 "\n"
3251 " A() {}\n"
3252 "};",
3253 format("class A : public QObject {\n"
3254 " Q_OBJECT\n"
3255 "\n"
3256 " A() {\n}\n"
3257 "} ;"));
3258 EXPECT_EQ("MACRO\n"
3259 "/*static*/ int i;",
3260 format("MACRO\n"
3261 " /*static*/ int i;"));
3262 EXPECT_EQ("SOME_MACRO\n"
3263 "namespace {\n"
3264 "void f();\n"
3265 "} // namespace",
3266 format("SOME_MACRO\n"
3267 " namespace {\n"
3268 "void f( );\n"
3269 "} // namespace"));
3270 // Only if the identifier contains at least 5 characters.
3271 EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3272 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3273 // Only if everything is upper case.
3274 EXPECT_EQ("class A : public QObject {\n"
3275 " Q_Object A() {}\n"
3276 "};",
3277 format("class A : public QObject {\n"
3278 " Q_Object\n"
3279 " A() {\n}\n"
3280 "} ;"));
3281
3282 // Only if the next line can actually start an unwrapped line.
3283 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3284 format("SOME_WEIRD_LOG_MACRO\n"
3285 "<< SomeThing;"));
3286
3287 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3288 "(n, buffers))\n",
3289 getChromiumStyle(FormatStyle::LK_Cpp));
3290
3291 // See PR41483
3292 EXPECT_EQ("/**/ FOO(a)\n"
3293 "FOO(b)",
3294 format("/**/ FOO(a)\n"
3295 "FOO(b)"));
3296}
3297
3298TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3299 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3300 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3301 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3302 "class X {};\n"
3303 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3304 "int *createScopDetectionPass() { return 0; }",
3305 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3306 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3307 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3308 " class X {};\n"
3309 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3310 " int *createScopDetectionPass() { return 0; }"));
3311 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3312 // braces, so that inner block is indented one level more.
3313 EXPECT_EQ("int q() {\n"
3314 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3315 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3316 " IPC_END_MESSAGE_MAP()\n"
3317 "}",
3318 format("int q() {\n"
3319 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3320 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3321 " IPC_END_MESSAGE_MAP()\n"
3322 "}"));
3323
3324 // Same inside macros.
3325 EXPECT_EQ("#define LIST(L) \\\n"
3326 " L(A) \\\n"
3327 " L(B) \\\n"
3328 " L(C)",
3329 format("#define LIST(L) \\\n"
3330 " L(A) \\\n"
3331 " L(B) \\\n"
3332 " L(C)",
3333 getGoogleStyle()));
3334
3335 // These must not be recognized as macros.
3336 EXPECT_EQ("int q() {\n"
3337 " f(x);\n"
3338 " f(x) {}\n"
3339 " f(x)->g();\n"
3340 " f(x)->*g();\n"
3341 " f(x).g();\n"
3342 " f(x) = x;\n"
3343 " f(x) += x;\n"
3344 " f(x) -= x;\n"
3345 " f(x) *= x;\n"
3346 " f(x) /= x;\n"
3347 " f(x) %= x;\n"
3348 " f(x) &= x;\n"
3349 " f(x) |= x;\n"
3350 " f(x) ^= x;\n"
3351 " f(x) >>= x;\n"
3352 " f(x) <<= x;\n"
3353 " f(x)[y].z();\n"
3354 " LOG(INFO) << x;\n"
3355 " ifstream(x) >> x;\n"
3356 "}\n",
3357 format("int q() {\n"
3358 " f(x)\n;\n"
3359 " f(x)\n {}\n"
3360 " f(x)\n->g();\n"
3361 " f(x)\n->*g();\n"
3362 " f(x)\n.g();\n"
3363 " f(x)\n = x;\n"
3364 " f(x)\n += x;\n"
3365 " f(x)\n -= x;\n"
3366 " f(x)\n *= x;\n"
3367 " f(x)\n /= x;\n"
3368 " f(x)\n %= x;\n"
3369 " f(x)\n &= x;\n"
3370 " f(x)\n |= x;\n"
3371 " f(x)\n ^= x;\n"
3372 " f(x)\n >>= x;\n"
3373 " f(x)\n <<= x;\n"
3374 " f(x)\n[y].z();\n"
3375 " LOG(INFO)\n << x;\n"
3376 " ifstream(x)\n >> x;\n"
3377 "}\n"));
3378 EXPECT_EQ("int q() {\n"
3379 " F(x)\n"
3380 " if (1) {\n"
3381 " }\n"
3382 " F(x)\n"
3383 " while (1) {\n"
3384 " }\n"
3385 " F(x)\n"
3386 " G(x);\n"
3387 " F(x)\n"
3388 " try {\n"
3389 " Q();\n"
3390 " } catch (...) {\n"
3391 " }\n"
3392 "}\n",
3393 format("int q() {\n"
3394 "F(x)\n"
3395 "if (1) {}\n"
3396 "F(x)\n"
3397 "while (1) {}\n"
3398 "F(x)\n"
3399 "G(x);\n"
3400 "F(x)\n"
3401 "try { Q(); } catch (...) {}\n"
3402 "}\n"));
3403 EXPECT_EQ("class A {\n"
3404 " A() : t(0) {}\n"
3405 " A(int i) noexcept() : {}\n"
3406 " A(X x)\n" // FIXME: function-level try blocks are broken.
3407 " try : t(0) {\n"
3408 " } catch (...) {\n"
3409 " }\n"
3410 "};",
3411 format("class A {\n"
3412 " A()\n : t(0) {}\n"
3413 " A(int i)\n noexcept() : {}\n"
3414 " A(X x)\n"
3415 " try : t(0) {} catch (...) {}\n"
3416 "};"));
3417 FormatStyle Style = getLLVMStyle();
3418 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3419 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3420 Style.BraceWrapping.AfterFunction = true;
3421 EXPECT_EQ("void f()\n"
3422 "try\n"
3423 "{\n"
3424 "}",
3425 format("void f() try {\n"
3426 "}",
3427 Style));
3428 EXPECT_EQ("class SomeClass {\n"
3429 "public:\n"
3430 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3431 "};",
3432 format("class SomeClass {\n"
3433 "public:\n"
3434 " SomeClass()\n"
3435 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3436 "};"));
3437 EXPECT_EQ("class SomeClass {\n"
3438 "public:\n"
3439 " SomeClass()\n"
3440 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3441 "};",
3442 format("class SomeClass {\n"
3443 "public:\n"
3444 " SomeClass()\n"
3445 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3446 "};",
3447 getLLVMStyleWithColumns(40)));
3448
3449 verifyFormat("MACRO(>)");
3450
3451 // Some macros contain an implicit semicolon.
3452 Style = getLLVMStyle();
3453 Style.StatementMacros.push_back("FOO");
3454 verifyFormat("FOO(a) int b = 0;");
3455 verifyFormat("FOO(a)\n"
3456 "int b = 0;",
3457 Style);
3458 verifyFormat("FOO(a);\n"
3459 "int b = 0;",
3460 Style);
3461 verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3462 "int b = 0;",
3463 Style);
3464 verifyFormat("FOO()\n"
3465 "int b = 0;",
3466 Style);
3467 verifyFormat("FOO\n"
3468 "int b = 0;",
3469 Style);
3470 verifyFormat("void f() {\n"
3471 " FOO(a)\n"
3472 " return a;\n"
3473 "}",
3474 Style);
3475 verifyFormat("FOO(a)\n"
3476 "FOO(b)",
3477 Style);
3478 verifyFormat("int a = 0;\n"
3479 "FOO(b)\n"
3480 "int c = 0;",
3481 Style);
3482 verifyFormat("int a = 0;\n"
3483 "int x = FOO(a)\n"
3484 "int b = 0;",
3485 Style);
3486 verifyFormat("void foo(int a) { FOO(a) }\n"
3487 "uint32_t bar() {}",
3488 Style);
3489}
3490
3491TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3492 verifyFormat("#define A \\\n"
3493 " f({ \\\n"
3494 " g(); \\\n"
3495 " });",
3496 getLLVMStyleWithColumns(11));
3497}
3498
3499TEST_F(FormatTest, IndentPreprocessorDirectives) {
3500 FormatStyle Style = getLLVMStyle();
3501 Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3502 Style.ColumnLimit = 40;
3503 verifyFormat("#ifdef _WIN32\n"
3504 "#define A 0\n"
3505 "#ifdef VAR2\n"
3506 "#define B 1\n"
3507 "#include <someheader.h>\n"
3508 "#define MACRO \\\n"
3509 " some_very_long_func_aaaaaaaaaa();\n"
3510 "#endif\n"
3511 "#else\n"
3512 "#define A 1\n"
3513 "#endif",
3514 Style);
3515 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3516 verifyFormat("#ifdef _WIN32\n"
3517 "# define A 0\n"
3518 "# ifdef VAR2\n"
3519 "# define B 1\n"
3520 "# include <someheader.h>\n"
3521 "# define MACRO \\\n"
3522 " some_very_long_func_aaaaaaaaaa();\n"
3523 "# endif\n"
3524 "#else\n"
3525 "# define A 1\n"
3526 "#endif",
3527 Style);
3528 verifyFormat("#if A\n"
3529 "# define MACRO \\\n"
3530 " void a(int x) { \\\n"
3531 " b(); \\\n"
3532 " c(); \\\n"
3533 " d(); \\\n"
3534 " e(); \\\n"
3535 " f(); \\\n"
3536 " }\n"
3537 "#endif",
3538 Style);
3539 // Comments before include guard.
3540 verifyFormat("// file comment\n"
3541 "// file comment\n"
3542 "#ifndef HEADER_H\n"
3543 "#define HEADER_H\n"
3544 "code();\n"
3545 "#endif",
3546 Style);
3547 // Test with include guards.
3548 verifyFormat("#ifndef HEADER_H\n"
3549 "#define HEADER_H\n"
3550 "code();\n"
3551 "#endif",
3552 Style);
3553 // Include guards must have a #define with the same variable immediately
3554 // after #ifndef.
3555 verifyFormat("#ifndef NOT_GUARD\n"
3556 "# define FOO\n"
3557 "code();\n"
3558 "#endif",
3559 Style);
3560
3561 // Include guards must cover the entire file.
3562 verifyFormat("code();\n"
3563 "code();\n"
3564 "#ifndef NOT_GUARD\n"
3565 "# define NOT_GUARD\n"
3566 "code();\n"
3567 "#endif",
3568 Style);
3569 verifyFormat("#ifndef NOT_GUARD\n"
3570 "# define NOT_GUARD\n"
3571 "code();\n"
3572 "#endif\n"
3573 "code();",
3574 Style);
3575 // Test with trailing blank lines.
3576 verifyFormat("#ifndef HEADER_H\n"
3577 "#define HEADER_H\n"
3578 "code();\n"
3579 "#endif\n",
3580 Style);
3581 // Include guards don't have #else.
3582 verifyFormat("#ifndef NOT_GUARD\n"
3583 "# define NOT_GUARD\n"
3584 "code();\n"
3585 "#else\n"
3586 "#endif",
3587 Style);
3588 verifyFormat("#ifndef NOT_GUARD\n"
3589 "# define NOT_GUARD\n"
3590 "code();\n"
3591 "#elif FOO\n"
3592 "#endif",
3593 Style);
3594 // Non-identifier #define after potential include guard.
3595 verifyFormat("#ifndef FOO\n"
3596 "# define 1\n"
3597 "#endif\n",
3598 Style);
3599 // #if closes past last non-preprocessor line.
3600 verifyFormat("#ifndef FOO\n"
3601 "#define FOO\n"
3602 "#if 1\n"
3603 "int i;\n"
3604 "# define A 0\n"
3605 "#endif\n"
3606 "#endif\n",
3607 Style);
3608 // Don't crash if there is an #elif directive without a condition.
3609 verifyFormat("#if 1\n"
3610 "int x;\n"
3611 "#elif\n"
3612 "int y;\n"
3613 "#else\n"
3614 "int z;\n"
3615 "#endif",
3616 Style);
3617 // FIXME: This doesn't handle the case where there's code between the
3618 // #ifndef and #define but all other conditions hold. This is because when
3619 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3620 // previous code line yet, so we can't detect it.
3621 EXPECT_EQ("#ifndef NOT_GUARD\n"
3622 "code();\n"
3623 "#define NOT_GUARD\n"
3624 "code();\n"
3625 "#endif",
3626 format("#ifndef NOT_GUARD\n"
3627 "code();\n"
3628 "# define NOT_GUARD\n"
3629 "code();\n"
3630 "#endif",
3631 Style));
3632 // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3633 // be outside an include guard. Examples are #pragma once and
3634 // #pragma GCC diagnostic, or anything else that does not change the meaning
3635 // of the file if it's included multiple times.
3636 EXPECT_EQ("#ifdef WIN32\n"
3637 "# pragma once\n"
3638 "#endif\n"
3639 "#ifndef HEADER_H\n"
3640 "# define HEADER_H\n"
3641 "code();\n"
3642 "#endif",
3643 format("#ifdef WIN32\n"
3644 "# pragma once\n"
3645 "#endif\n"
3646 "#ifndef HEADER_H\n"
3647 "#define HEADER_H\n"
3648 "code();\n"
3649 "#endif",
3650 Style));
3651 // FIXME: This does not detect when there is a single non-preprocessor line
3652 // in front of an include-guard-like structure where other conditions hold
3653 // because ScopedLineState hides the line.
3654 EXPECT_EQ("code();\n"
3655 "#ifndef HEADER_H\n"
3656 "#define HEADER_H\n"
3657 "code();\n"
3658 "#endif",
3659 format("code();\n"
3660 "#ifndef HEADER_H\n"
3661 "# define HEADER_H\n"
3662 "code();\n"
3663 "#endif",
3664 Style));
3665 // Keep comments aligned with #, otherwise indent comments normally. These
3666 // tests cannot use verifyFormat because messUp manipulates leading
3667 // whitespace.
3668 {
3669 const char *Expected = ""
3670 "void f() {\n"
3671 "#if 1\n"
3672 "// Preprocessor aligned.\n"
3673 "# define A 0\n"
3674 " // Code. Separated by blank line.\n"
3675 "\n"
3676 "# define B 0\n"
3677 " // Code. Not aligned with #\n"
3678 "# define C 0\n"
3679 "#endif";
3680 const char *ToFormat = ""
3681 "void f() {\n"
3682 "#if 1\n"
3683 "// Preprocessor aligned.\n"
3684 "# define A 0\n"
3685 "// Code. Separated by blank line.\n"
3686 "\n"
3687 "# define B 0\n"
3688 " // Code. Not aligned with #\n"
3689 "# define C 0\n"
3690 "#endif";
3691 EXPECT_EQ(Expected, format(ToFormat, Style));
3692 EXPECT_EQ(Expected, format(Expected, Style));
3693 }
3694 // Keep block quotes aligned.
3695 {
3696 const char *Expected = ""
3697 "void f() {\n"
3698 "#if 1\n"
3699 "/* Preprocessor aligned. */\n"
3700 "# define A 0\n"
3701 " /* Code. Separated by blank line. */\n"
3702 "\n"
3703 "# define B 0\n"
3704 " /* Code. Not aligned with # */\n"
3705 "# define C 0\n"
3706 "#endif";
3707 const char *ToFormat = ""
3708 "void f() {\n"
3709 "#if 1\n"
3710 "/* Preprocessor aligned. */\n"
3711 "# define A 0\n"
3712 "/* Code. Separated by blank line. */\n"
3713 "\n"
3714 "# define B 0\n"
3715 " /* Code. Not aligned with # */\n"
3716 "# define C 0\n"
3717 "#endif";
3718 EXPECT_EQ(Expected, format(ToFormat, Style));
3719 EXPECT_EQ(Expected, format(Expected, Style));
3720 }
3721 // Keep comments aligned with un-indented directives.
3722 {
3723 const char *Expected = ""
3724 "void f() {\n"
3725 "// Preprocessor aligned.\n"
3726 "#define A 0\n"
3727 " // Code. Separated by blank line.\n"
3728 "\n"
3729 "#define B 0\n"
3730 " // Code. Not aligned with #\n"
3731 "#define C 0\n";
3732 const char *ToFormat = ""
3733 "void f() {\n"
3734 "// Preprocessor aligned.\n"
3735 "#define A 0\n"
3736 "// Code. Separated by blank line.\n"
3737 "\n"
3738 "#define B 0\n"
3739 " // Code. Not aligned with #\n"
3740 "#define C 0\n";
3741 EXPECT_EQ(Expected, format(ToFormat, Style));
3742 EXPECT_EQ(Expected, format(Expected, Style));
3743 }
3744 // Test AfterHash with tabs.
3745 {
3746 FormatStyle Tabbed = Style;
3747 Tabbed.UseTab = FormatStyle::UT_Always;
3748 Tabbed.IndentWidth = 8;
3749 Tabbed.TabWidth = 8;
3750 verifyFormat("#ifdef _WIN32\n"
3751 "#\tdefine A 0\n"
3752 "#\tifdef VAR2\n"
3753 "#\t\tdefine B 1\n"
3754 "#\t\tinclude <someheader.h>\n"
3755 "#\t\tdefine MACRO \\\n"
3756 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3757 "#\tendif\n"
3758 "#else\n"
3759 "#\tdefine A 1\n"
3760 "#endif",
3761 Tabbed);
3762 }
3763
3764 // Regression test: Multiline-macro inside include guards.
3765 verifyFormat("#ifndef HEADER_H\n"
3766 "#define HEADER_H\n"
3767 "#define A() \\\n"
3768 " int i; \\\n"
3769 " int j;\n"
3770 "#endif // HEADER_H",
3771 getLLVMStyleWithColumns(20));
3772
3773 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3774 // Basic before hash indent tests
3775 verifyFormat("#ifdef _WIN32\n"
3776 " #define A 0\n"
3777 " #ifdef VAR2\n"
3778 " #define B 1\n"
3779 " #include <someheader.h>\n"
3780 " #define MACRO \\\n"
3781 " some_very_long_func_aaaaaaaaaa();\n"
3782 " #endif\n"
3783 "#else\n"
3784 " #define A 1\n"
3785 "#endif",
3786 Style);
3787 verifyFormat("#if A\n"
3788 " #define MACRO \\\n"
3789 " void a(int x) { \\\n"
3790 " b(); \\\n"
3791 " c(); \\\n"
3792 " d(); \\\n"
3793 " e(); \\\n"
3794 " f(); \\\n"
3795 " }\n"
3796 "#endif",
3797 Style);
3798 // Keep comments aligned with indented directives. These
3799 // tests cannot use verifyFormat because messUp manipulates leading
3800 // whitespace.
3801 {
3802 const char *Expected = "void f() {\n"
3803 "// Aligned to preprocessor.\n"
3804 "#if 1\n"
3805 " // Aligned to code.\n"
3806 " int a;\n"
3807 " #if 1\n"
3808 " // Aligned to preprocessor.\n"
3809 " #define A 0\n"
3810 " // Aligned to code.\n"
3811 " int b;\n"
3812 " #endif\n"
3813 "#endif\n"
3814 "}";
3815 const char *ToFormat = "void f() {\n"
3816 "// Aligned to preprocessor.\n"
3817 "#if 1\n"
3818 "// Aligned to code.\n"
3819 "int a;\n"
3820 "#if 1\n"
3821 "// Aligned to preprocessor.\n"
3822 "#define A 0\n"
3823 "// Aligned to code.\n"
3824 "int b;\n"
3825 "#endif\n"
3826 "#endif\n"
3827 "}";
3828 EXPECT_EQ(Expected, format(ToFormat, Style));
3829 EXPECT_EQ(Expected, format(Expected, Style));
3830 }
3831 {
3832 const char *Expected = "void f() {\n"
3833 "/* Aligned to preprocessor. */\n"
3834 "#if 1\n"
3835 " /* Aligned to code. */\n"
3836 " int a;\n"
3837 " #if 1\n"
3838 " /* Aligned to preprocessor. */\n"
3839 " #define A 0\n"
3840 " /* Aligned to code. */\n"
3841 " int b;\n"
3842 " #endif\n"
3843 "#endif\n"
3844 "}";
3845 const char *ToFormat = "void f() {\n"
3846 "/* Aligned to preprocessor. */\n"
3847 "#if 1\n"
3848 "/* Aligned to code. */\n"
3849 "int a;\n"
3850 "#if 1\n"
3851 "/* Aligned to preprocessor. */\n"
3852 "#define A 0\n"
3853 "/* Aligned to code. */\n"
3854 "int b;\n"
3855 "#endif\n"
3856 "#endif\n"
3857 "}";
3858 EXPECT_EQ(Expected, format(ToFormat, Style));
3859 EXPECT_EQ(Expected, format(Expected, Style));
3860 }
3861
3862 // Test single comment before preprocessor
3863 verifyFormat("// Comment\n"
3864 "\n"
3865 "#if 1\n"
3866 "#endif",
3867 Style);
3868}
3869
3870TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3871 verifyFormat("{\n { a #c; }\n}");
3872}
3873
3874TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3875 EXPECT_EQ("#define A \\\n { \\\n {\nint i;",
3876 format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3877 EXPECT_EQ("#define A \\\n } \\\n }\nint i;",
3878 format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3879}
3880
3881TEST_F(FormatTest, EscapedNewlines) {
3882 FormatStyle Narrow = getLLVMStyleWithColumns(11);
3883 EXPECT_EQ("#define A \\\n int i; \\\n int j;",
3884 format("#define A \\\nint i;\\\n int j;", Narrow));
3885 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3886 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3887 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));
3888 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3889
3890 FormatStyle AlignLeft = getLLVMStyle();
3891 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3892 EXPECT_EQ("#define MACRO(x) \\\n"
3893 "private: \\\n"
3894 " int x(int a);\n",
3895 format("#define MACRO(x) \\\n"
3896 "private: \\\n"
3897 " int x(int a);\n",
3898 AlignLeft));
3899
3900 // CRLF line endings
3901 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;",
3902 format("#define A \\\r\nint i;\\\r\n int j;", Narrow));
3903 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3904 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3905 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */"));
3906 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3907 EXPECT_EQ("#define MACRO(x) \\\r\n"
3908 "private: \\\r\n"
3909 " int x(int a);\r\n",
3910 format("#define MACRO(x) \\\r\n"
3911 "private: \\\r\n"
3912 " int x(int a);\r\n",
3913 AlignLeft));
3914
3915 FormatStyle DontAlign = getLLVMStyle();
3916 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3917 DontAlign.MaxEmptyLinesToKeep = 3;
3918 // FIXME: can't use verifyFormat here because the newline before
3919 // "public:" is not inserted the first time it's reformatted
3920 EXPECT_EQ("#define A \\\n"
3921 " class Foo { \\\n"
3922 " void bar(); \\\n"
3923 "\\\n"
3924 "\\\n"
3925 "\\\n"
3926 " public: \\\n"
3927 " void baz(); \\\n"
3928 " };",
3929 format("#define A \\\n"
3930 " class Foo { \\\n"
3931 " void bar(); \\\n"
3932 "\\\n"
3933 "\\\n"
3934 "\\\n"
3935 " public: \\\n"
3936 " void baz(); \\\n"
3937 " };",
3938 DontAlign));
3939}
3940
3941TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3942 verifyFormat("#define A \\\n"
3943 " int v( \\\n"
3944 " a); \\\n"
3945 " int i;",
3946 getLLVMStyleWithColumns(11));
3947}
3948
3949TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3950 EXPECT_EQ(
3951 "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3952 " \\\n"
3953 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3954 "\n"
3955 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3956 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3957 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("
3958 "\\\n"
3959 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3960 " \n"
3961 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3962 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3963}
3964
3965TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3966 EXPECT_EQ("int\n"
3967 "#define A\n"
3968 " a;",
3969 format("int\n#define A\na;"));
3970 verifyFormat("functionCallTo(\n"
3971 " someOtherFunction(\n"
3972 " withSomeParameters, whichInSequence,\n"
3973 " areLongerThanALine(andAnotherCall,\n"
3974 "#define A B\n"
3975 " withMoreParamters,\n"
3976 " whichStronglyInfluenceTheLayout),\n"
3977 " andMoreParameters),\n"
3978 " trailing);",
3979 getLLVMStyleWithColumns(69));
3980 verifyFormat("Foo::Foo()\n"
3981 "#ifdef BAR\n"
3982 " : baz(0)\n"
3983 "#endif\n"
3984 "{\n"
3985 "}");
3986 verifyFormat("void f() {\n"
3987 " if (true)\n"
3988 "#ifdef A\n"
3989 " f(42);\n"
3990 " x();\n"
3991 "#else\n"
3992 " g();\n"
3993 " x();\n"
3994 "#endif\n"
3995 "}");
3996 verifyFormat("void f(param1, param2,\n"
3997 " param3,\n"
3998 "#ifdef A\n"
3999 " param4(param5,\n"
4000 "#ifdef A1\n"
4001 " param6,\n"
4002 "#ifdef A2\n"
4003 " param7),\n"
4004 "#else\n"
4005 " param8),\n"
4006 " param9,\n"
4007 "#endif\n"
4008 " param10,\n"
4009 "#endif\n"
4010 " param11)\n"
4011 "#else\n"
4012 " param12)\n"
4013 "#endif\n"
4014 "{\n"
4015 " x();\n"
4016 "}",
4017 getLLVMStyleWithColumns(28));
4018 verifyFormat("#if 1\n"
4019 "int i;");
4020 verifyFormat("#if 1\n"
4021 "#endif\n"
4022 "#if 1\n"
4023 "#else\n"
4024 "#endif\n");
4025 verifyFormat("DEBUG({\n"
4026 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
4028 "});\n"
4029 "#if a\n"
4030 "#else\n"
4031 "#endif");
4032
4033 verifyIncompleteFormat("void f(\n"
4034 "#if A\n"
4035 ");\n"
4036 "#else\n"
4037 "#endif");
4038}
4039
4040TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
4041 verifyFormat("#endif\n"
4042 "#if B");
4043}
4044
4045TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
4046 FormatStyle SingleLine = getLLVMStyle();
4047 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
4048 verifyFormat("#if 0\n"
4049 "#elif 1\n"
4050 "#endif\n"
4051 "void foo() {\n"
4052 " if (test) foo2();\n"
4053 "}",
4054 SingleLine);
4055}
4056
4057TEST_F(FormatTest, LayoutBlockInsideParens) {
4058 verifyFormat("functionCall({ int i; });");
4059 verifyFormat("functionCall({\n"
4060 " int i;\n"
4061 " int j;\n"
4062 "});");
4063 verifyFormat("functionCall(\n"
4064 " {\n"
4065 " int i;\n"
4066 " int j;\n"
4067 " },\n"
4068 " aaaa, bbbb, cccc);");
4069 verifyFormat("functionA(functionB({\n"
4070 " int i;\n"
4071 " int j;\n"
4072 " }),\n"
4073 " aaaa, bbbb, cccc);");
4074 verifyFormat("functionCall(\n"
4075 " {\n"
4076 " int i;\n"
4077 " int j;\n"
4078 " },\n"
4079 " aaaa, bbbb, // comment\n"
4080 " cccc);");
4081 verifyFormat("functionA(functionB({\n"
4082 " int i;\n"
4083 " int j;\n"
4084 " }),\n"
4085 " aaaa, bbbb, // comment\n"
4086 " cccc);");
4087 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4088 verifyFormat("functionCall(aaaa, bbbb, {\n"
4089 " int i;\n"
4090 " int j;\n"
4091 "});");
4092 verifyFormat(
4093 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4094 " {\n"
4095 " int i; // break\n"
4096 " },\n"
4097 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4098 " ccccccccccccccccc));");
4099 verifyFormat("DEBUG({\n"
4100 " if (a)\n"
4101 " f();\n"
4102 "});");
4103}
4104
4105TEST_F(FormatTest, LayoutBlockInsideStatement) {
4106 EXPECT_EQ("SOME_MACRO { int i; }\n"
4107 "int i;",
4108 format(" SOME_MACRO {int i;} int i;"));
4109}
4110
4111TEST_F(FormatTest, LayoutNestedBlocks) {
4112 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4113 " struct s {\n"
4114 " int i;\n"
4115 " };\n"
4116 " s kBitsToOs[] = {{10}};\n"
4117 " for (int i = 0; i < 10; ++i)\n"
4118 " return;\n"
4119 "}");
4120 verifyFormat("call(parameter, {\n"
4121 " something();\n"
4122 " // Comment using all columns.\n"
4123 " somethingelse();\n"
4124 "});",
4125 getLLVMStyleWithColumns(40));
4126 verifyFormat("DEBUG( //\n"
4127 " { f(); }, a);");
4128 verifyFormat("DEBUG( //\n"
4129 " {\n"
4130 " f(); //\n"
4131 " },\n"
4132 " a);");
4133
4134 EXPECT_EQ("call(parameter, {\n"
4135 " something();\n"
4136 " // Comment too\n"
4137 " // looooooooooong.\n"
4138 " somethingElse();\n"
4139 "});",
4140 format("call(parameter, {\n"
4141 " something();\n"
4142 " // Comment too looooooooooong.\n"
4143 " somethingElse();\n"
4144 "});",
4145 getLLVMStyleWithColumns(29)));
4146 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));
4147 EXPECT_EQ("DEBUG({ // comment\n"
4148 " int i;\n"
4149 "});",
4150 format("DEBUG({ // comment\n"
4151 "int i;\n"
4152 "});"));
4153 EXPECT_EQ("DEBUG({\n"
4154 " int i;\n"
4155 "\n"
4156 " // comment\n"
4157 " int j;\n"
4158 "});",
4159 format("DEBUG({\n"
4160 " int i;\n"
4161 "\n"
4162 " // comment\n"
4163 " int j;\n"
4164 "});"));
4165
4166 verifyFormat("DEBUG({\n"
4167 " if (a)\n"
4168 " return;\n"
4169 "});");
4170 verifyGoogleFormat("DEBUG({\n"
4171 " if (a) return;\n"
4172 "});");
4173 FormatStyle Style = getGoogleStyle();
4174 Style.ColumnLimit = 45;
4175 verifyFormat("Debug(\n"
4176 " aaaaa,\n"
4177 " {\n"
4178 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4179 " },\n"
4180 " a);",
4181 Style);
4182
4183 verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4184
4185 verifyNoCrash("^{v^{a}}");
4186}
4187
4188TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4189 EXPECT_EQ("#define MACRO() \\\n"
4190 " Debug(aaa, /* force line break */ \\\n"
4191 " { \\\n"
4192 " int i; \\\n"
4193 " int j; \\\n"
4194 " })",
4195 format("#define MACRO() Debug(aaa, /* force line break */ \\\n"
4196 " { int i; int j; })",
4197 getGoogleStyle()));
4198
4199 EXPECT_EQ("#define A \\\n"
4200 " [] { \\\n"
4201 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4202 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4203 " }",
4204 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4205 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4206 getGoogleStyle()));
4207}
4208
4209TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4210 EXPECT_EQ("{}", format("{}"));
4211 verifyFormat("enum E {};");
4212 verifyFormat("enum E {}");
4213 FormatStyle Style = getLLVMStyle();
4214 Style.SpaceInEmptyBlock = true;
4215 EXPECT_EQ("void f() { }", format("void f() {}", Style));
4216 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4217 EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4218}
4219
4220TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4221 FormatStyle Style = getLLVMStyle();
4222 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4223 Style.MacroBlockEnd = "^[A-Z_]+_END$";
4224 verifyFormat("FOO_BEGIN\n"
4225 " FOO_ENTRY\n"
4226 "FOO_END",
4227 Style);
4228 verifyFormat("FOO_BEGIN\n"
4229 " NESTED_FOO_BEGIN\n"
4230 " NESTED_FOO_ENTRY\n"
4231 " NESTED_FOO_END\n"
4232 "FOO_END",
4233 Style);
4234 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4235 " int x;\n"
4236 " x = 1;\n"
4237 "FOO_END(Baz)",
4238 Style);
4239}
4240
4241//===----------------------------------------------------------------------===//
4242// Line break tests.
4243//===----------------------------------------------------------------------===//
4244
4245TEST_F(FormatTest, PreventConfusingIndents) {
4246 verifyFormat(
4247 "void f() {\n"
4248 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4249 " parameter, parameter, parameter)),\n"
4250 " SecondLongCall(parameter));\n"
4251 "}");
4252 verifyFormat(
4253 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4254 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4256 " aaaaaaaaaaaaaaaaaaaaaaaa);");
4257 verifyFormat(
4258 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4259 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4260 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4261 " [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4262 verifyFormat(
4263 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4264 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4265 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4266 " aaaaaaaaaaaaaaaaaaaaaaaa>;");
4267 verifyFormat("int a = bbbb && ccc &&\n"
4268 " fffff(\n"
4269 "#define A Just forcing a new line\n"
4270 " ddd);");
4271}
4272
4273TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4274 verifyFormat(
4275 "bool aaaaaaa =\n"
4276 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4277 " bbbbbbbb();");
4278 verifyFormat(
4279 "bool aaaaaaa =\n"
4280 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4281 " bbbbbbbb();");
4282
4283 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4284 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4285 " ccccccccc == ddddddddddd;");
4286 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4287 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4288 " ccccccccc == ddddddddddd;");
4289 verifyFormat(
4290 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4291 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4292 " ccccccccc == ddddddddddd;");
4293
4294 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4295 " aaaaaa) &&\n"
4296 " bbbbbb && cccccc;");
4297 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4298 " aaaaaa) >>\n"
4299 " bbbbbb;");
4300 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4301 " SourceMgr.getSpellingColumnNumber(\n"
4302 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4303 " 1);");
4304
4305 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4306 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4307 " cccccc) {\n}");
4308 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4309 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4310 " cccccc) {\n}");
4311 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4312 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4313 " cccccc) {\n}");
4314 verifyFormat("b = a &&\n"
4315 " // Comment\n"
4316 " b.c && d;");
4317
4318 // If the LHS of a comparison is not a binary expression itself, the
4319 // additional linebreak confuses many people.
4320 verifyFormat(
4321 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4323 "}");
4324 verifyFormat(
4325 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4327 "}");
4328 verifyFormat(
4329 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4331 "}");
4332 verifyFormat(
4333 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4334 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4335 "}");
4336 // Even explicit parentheses stress the precedence enough to make the
4337 // additional break unnecessary.
4338 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4340 "}");
4341 // This cases is borderline, but with the indentation it is still readable.
4342 verifyFormat(
4343 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4344 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4346 "}",
4347 getLLVMStyleWithColumns(75));
4348
4349 // If the LHS is a binary expression, we should still use the additional break
4350 // as otherwise the formatting hides the operator precedence.
4351 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4352 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4353 " 5) {\n"
4354 "}");
4355 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4356 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4357 " 5) {\n"
4358 "}");
4359
4360 FormatStyle OnePerLine = getLLVMStyle();
4361 OnePerLine.BinPackParameters = false;
4362 verifyFormat(
4363 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4364 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4366 OnePerLine);
4367
4368 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4369 " .aaa(aaaaaaaaaaaaa) *\n"
4370 " aaaaaaa +\n"
4371 " aaaaaaa;",
4372 getLLVMStyleWithColumns(40));
4373}
4374
4375TEST_F(FormatTest, ExpressionIndentation) {
4376 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4378 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4379 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4380 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4381 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4382 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4383 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4384 " ccccccccccccccccccccccccccccccccccccccccc;");
4385 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4387 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4388 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4389 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4390 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4391 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4392 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4393 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4395 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4396 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4397 verifyFormat("if () {\n"
4398 "} else if (aaaaa && bbbbb > // break\n"
4399 " ccccc) {\n"
4400 "}");
4401 verifyFormat("if () {\n"
4402 "} else if constexpr (aaaaa && bbbbb > // break\n"
4403 " ccccc) {\n"
4404 "}");
4405 verifyFormat("if () {\n"
4406 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4407 " ccccc) {\n"
4408 "}");
4409 verifyFormat("if () {\n"
4410 "} else if (aaaaa &&\n"
4411 " bbbbb > // break\n"
4412 " ccccc &&\n"
4413 " ddddd) {\n"
4414 "}");
4415
4416 // Presence of a trailing comment used to change indentation of b.
4417 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4418 " b;\n"
4419 "return aaaaaaaaaaaaaaaaaaa +\n"
4420 " b; //",
4421 getLLVMStyleWithColumns(30));
4422}
4423
4424TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4425 // Not sure what the best system is here. Like this, the LHS can be found
4426 // immediately above an operator (everything with the same or a higher
4427 // indent). The RHS is aligned right of the operator and so compasses
4428 // everything until something with the same indent as the operator is found.
4429 // FIXME: Is this a good system?
4430 FormatStyle Style = getLLVMStyle();
4431 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4432 verifyFormat(
4433 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4434 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4435 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4436 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4437 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4438 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4439 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4440 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4441 " > ccccccccccccccccccccccccccccccccccccccccc;",
4442 Style);
4443 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4444 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4445 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4446 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4447 Style);
4448 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4449 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4450 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4451 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4452 Style);
4453 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4454 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4455 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4456 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4457 Style);
4458 verifyFormat("if () {\n"
4459 "} else if (aaaaa\n"
4460 " && bbbbb // break\n"
4461 " > ccccc) {\n"
4462 "}",
4463 Style);
4464 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4465 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4466 Style);
4467 verifyFormat("return (a)\n"
4468 " // comment\n"
4469 " + b;",
4470 Style);
4471 verifyFormat(
4472 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4473 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4474 " + cc;",
4475 Style);
4476
4477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4478 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4479 Style);
4480
4481 // Forced by comments.
4482 verifyFormat(
4483 "unsigned ContentSize =\n"
4484 " sizeof(int16_t) // DWARF ARange version number\n"
4485 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4486 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
4487 " + sizeof(int8_t); // Segment Size (in bytes)");
4488
4489 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4490 " == boost::fusion::at_c<1>(iiii).second;",
4491 Style);
4492
4493 Style.ColumnLimit = 60;
4494 verifyFormat("zzzzzzzzzz\n"
4495 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4496 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4497 Style);
4498
4499 Style.ColumnLimit = 80;
4500 Style.IndentWidth = 4;
4501 Style.TabWidth = 4;
4502 Style.UseTab = FormatStyle::UT_Always;
4503 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4504 Style.AlignOperands = FormatStyle::OAS_DontAlign;
4505 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4506 "\t&& (someOtherLongishConditionPart1\n"
4507 "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4508 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4509 "(someOtherLongishConditionPart1 || "
4510 "someOtherEvenLongerNestedConditionPart2);",
4511 Style));
4512}
4513
4514TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4515 FormatStyle Style = getLLVMStyle();
4516 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4517 Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4518
4519 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4520 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4522 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4523 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4524 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4525 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4526 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4527 " > ccccccccccccccccccccccccccccccccccccccccc;",
4528 Style);
4529 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4530 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4531 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4532 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4533 Style);
4534 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4535 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4536 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4537 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4538 Style);
4539 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4540 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4541 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4542 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4543 Style);
4544 verifyFormat("if () {\n"
4545 "} else if (aaaaa\n"
4546 " && bbbbb // break\n"
4547 " > ccccc) {\n"
4548 "}",
4549 Style);
4550 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4551 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4552 Style);
4553 verifyFormat("return (a)\n"
4554 " // comment\n"
4555 " + b;",
4556 Style);
4557 verifyFormat(
4558 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4559 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4560 " + cc;",
4561 Style);
4562 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4563 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4564 " : 3333333333333333;",
4565 Style);
4566 verifyFormat(
4567 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
4568 " : ccccccccccccccc ? dddddddddddddddddd\n"
4569 " : eeeeeeeeeeeeeeeeee)\n"
4570 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4571 " : 3333333333333333;",
4572 Style);
4573 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4574 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4575 Style);
4576
4577 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4578 " == boost::fusion::at_c<1>(iiii).second;",
4579 Style);
4580
4581 Style.ColumnLimit = 60;
4582 verifyFormat("zzzzzzzzzzzzz\n"
4583 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4584 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4585 Style);
4586
4587 // Forced by comments.
4588 Style.ColumnLimit = 80;
4589 verifyFormat(
4590 "unsigned ContentSize\n"
4591 " = sizeof(int16_t) // DWARF ARange version number\n"
4592 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4593 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
4594 " + sizeof(int8_t); // Segment Size (in bytes)",
4595 Style);
4596
4597 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4598 verifyFormat(
4599 "unsigned ContentSize =\n"
4600 " sizeof(int16_t) // DWARF ARange version number\n"
4601 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4602 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
4603 " + sizeof(int8_t); // Segment Size (in bytes)",
4604 Style);
4605
4606 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4607 verifyFormat(
4608 "unsigned ContentSize =\n"
4609 " sizeof(int16_t) // DWARF ARange version number\n"
4610 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4611 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
4612 " + sizeof(int8_t); // Segment Size (in bytes)",
4613 Style);
4614}
4615
4616TEST_F(FormatTest, EnforcedOperatorWraps) {
4617 // Here we'd like to wrap after the || operators, but a comment is forcing an
4618 // earlier wrap.
4619 verifyFormat("bool x = aaaaa //\n"
4620 " || bbbbb\n"
4621 " //\n"
4622 " || cccc;");
4623}
4624
4625TEST_F(FormatTest, NoOperandAlignment) {
4626 FormatStyle Style = getLLVMStyle();
4627 Style.AlignOperands = FormatStyle::OAS_DontAlign;
4628 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4629 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4630 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4631 Style);
4632 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4633 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4634 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4635 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4636 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4637 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4638 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4639 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4640 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4641 " > ccccccccccccccccccccccccccccccccccccccccc;",
4642 Style);
4643
4644 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4645 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4646 " + cc;",
4647 Style);
4648 verifyFormat("int a = aa\n"
4649 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4650 " * cccccccccccccccccccccccccccccccccccc;\n",
4651 Style);
4652
4653 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4654 verifyFormat("return (a > b\n"
4655 " // comment1\n"
4656 " // comment2\n"
4657 " || c);",
4658 Style);
4659}
4660
4661TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4662 FormatStyle Style = getLLVMStyle();
4663 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4664 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4666 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4667 Style);
4668}
4669
4670TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4671 FormatStyle Style = getLLVMStyle();
4672 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4673 Style.BinPackArguments = false;
4674 Style.ColumnLimit = 40;
4675 verifyFormat("void test() {\n"
4676 " someFunction(\n"
4677 " this + argument + is + quite\n"
4678 " + long + so + it + gets + wrapped\n"
4679 " + but + remains + bin - packed);\n"
4680 "}",
4681 Style);
4682 verifyFormat("void test() {\n"
4683 " someFunction(arg1,\n"
4684 " this + argument + is\n"
4685 " + quite + long + so\n"
4686 " + it + gets + wrapped\n"
4687 " + but + remains + bin\n"
4688 " - packed,\n"
4689 " arg3);\n"
4690 "}",
4691 Style);
4692 verifyFormat("void test() {\n"
4693 " someFunction(\n"
4694 " arg1,\n"
4695 " this + argument + has\n"
4696 " + anotherFunc(nested,\n"
4697 " calls + whose\n"
4698 " + arguments\n"
4699 " + are + also\n"
4700 " + wrapped,\n"
4701 " in + addition)\n"
4702 " + to + being + bin - packed,\n"
4703 " arg3);\n"
4704 "}",
4705 Style);
4706
4707 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4708 verifyFormat("void test() {\n"
4709 " someFunction(\n"
4710 " arg1,\n"
4711 " this + argument + has +\n"
4712 " anotherFunc(nested,\n"
4713 " calls + whose +\n"
4714 " arguments +\n"
4715 " are + also +\n"
4716 " wrapped,\n"
4717 " in + addition) +\n"
4718 " to + being + bin - packed,\n"
4719 " arg3);\n"
4720 "}",
4721 Style);
4722}
4723
4724TEST_F(FormatTest, ConstructorInitializers) {
4725 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4726 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4727 getLLVMStyleWithColumns(45));
4728 verifyFormat("Constructor()\n"
4729 " : Inttializer(FitsOnTheLine) {}",
4730 getLLVMStyleWithColumns(44));
4731 verifyFormat("Constructor()\n"
4732 " : Inttializer(FitsOnTheLine) {}",
4733 getLLVMStyleWithColumns(43));
4734
4735 verifyFormat("template <typename T>\n"
4736 "Constructor() : Initializer(FitsOnTheLine) {}",
4737 getLLVMStyleWithColumns(45));
4738
4739 verifyFormat(
4740 "SomeClass::Constructor()\n"
4741 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4742
4743 verifyFormat(
4744 "SomeClass::Constructor()\n"
4745 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4746 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4747 verifyFormat(
4748 "SomeClass::Constructor()\n"
4749 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4750 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4751 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4752 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4753 " : aaaaaaaaaa(aaaaaa) {}");
4754
4755 verifyFormat("Constructor()\n"
4756 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4757 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4758 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4759 " aaaaaaaaaaaaaaaaaaaaaaa() {}");
4760
4761 verifyFormat("Constructor()\n"
4762 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4764
4765 verifyFormat("Constructor(int Parameter = 0)\n"
4766 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4767 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4768 verifyFormat("Constructor()\n"
4769 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4770 "}",
4771 getLLVMStyleWithColumns(60));
4772 verifyFormat("Constructor()\n"
4773 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4774 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4775
4776 // Here a line could be saved by splitting the second initializer onto two
4777 // lines, but that is not desirable.
4778 verifyFormat("Constructor()\n"
4779 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4780 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
4781 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4782
4783 FormatStyle OnePerLine = getLLVMStyle();
4784 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4785 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4786 verifyFormat("SomeClass::Constructor()\n"
4787 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4788 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4789 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4790 OnePerLine);
4791 verifyFormat("SomeClass::Constructor()\n"
4792 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4793 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4794 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4795 OnePerLine);
4796 verifyFormat("MyClass::MyClass(int var)\n"
4797 " : some_var_(var), // 4 space indent\n"
4798 " some_other_var_(var + 1) { // lined up\n"
4799 "}",
4800 OnePerLine);
4801 verifyFormat("Constructor()\n"
4802 " : aaaaa(aaaaaa),\n"
4803 " aaaaa(aaaaaa),\n"
4804 " aaaaa(aaaaaa),\n"
4805 " aaaaa(aaaaaa),\n"
4806 " aaaaa(aaaaaa) {}",
4807 OnePerLine);
4808 verifyFormat("Constructor()\n"
4809 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4810 " aaaaaaaaaaaaaaaaaaaaaa) {}",
4811 OnePerLine);
4812 OnePerLine.BinPackParameters = false;
4813 verifyFormat(
4814 "Constructor()\n"
4815 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4816 " aaaaaaaaaaa().aaa(),\n"
4817 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4818 OnePerLine);
4819 OnePerLine.ColumnLimit = 60;
4820 verifyFormat("Constructor()\n"
4821 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
4822 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4823 OnePerLine);
4824
4825 EXPECT_EQ("Constructor()\n"
4826 " : // Comment forcing unwanted break.\n"
4827 " aaaa(aaaa) {}",
4828 format("Constructor() :\n"
4829 " // Comment forcing unwanted break.\n"
4830 " aaaa(aaaa) {}"));
4831}
4832
4833TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4834 FormatStyle Style = getLLVMStyle();
4835 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4836 Style.ColumnLimit = 60;
4837 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4838 Style.AllowAllConstructorInitializersOnNextLine = true;
4839 Style.BinPackParameters = false;
4840
4841 for (int i = 0; i < 4; ++i) {
4842 // Test all combinations of parameters that should not have an effect.
4843 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4844 Style.AllowAllArgumentsOnNextLine = i & 2;
4845
4846 Style.AllowAllConstructorInitializersOnNextLine = true;
4847 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4848 verifyFormat("Constructor()\n"
4849 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4850 Style);
4851 verifyFormat("Constructor() : a(a), b(b) {}", Style);
4852
4853 Style.AllowAllConstructorInitializersOnNextLine = false;
4854 verifyFormat("Constructor()\n"
4855 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
4856 " , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4857 Style);
4858 verifyFormat("Constructor() : a(a), b(b) {}", Style);
4859
4860 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4861 Style.AllowAllConstructorInitializersOnNextLine = true;
4862 verifyFormat("Constructor()\n"
4863 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4864 Style);
4865
4866 Style.AllowAllConstructorInitializersOnNextLine = false;
4867 verifyFormat("Constructor()\n"
4868 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
4869 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4870 Style);
4871
4872 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4873 Style.AllowAllConstructorInitializersOnNextLine = true;
4874 verifyFormat("Constructor() :\n"
4875 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4876 Style);
4877
4878 Style.AllowAllConstructorInitializersOnNextLine = false;
4879 verifyFormat("Constructor() :\n"
4880 " aaaaaaaaaaaaaaaaaa(a),\n"
4881 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4882 Style);
4883 }
4884
4885 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4886 // AllowAllConstructorInitializersOnNextLine in all
4887 // BreakConstructorInitializers modes
4888 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4889 Style.AllowAllParametersOfDeclarationOnNextLine = true;
4890 Style.AllowAllConstructorInitializersOnNextLine = false;
4891 verifyFormat("SomeClassWithALongName::Constructor(\n"
4892 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4893 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
4894 " , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4895 Style);
4896
4897 Style.AllowAllConstructorInitializersOnNextLine = true;
4898 verifyFormat("SomeClassWithALongName::Constructor(\n"
4899 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4900 " int bbbbbbbbbbbbb,\n"
4901 " int cccccccccccccccc)\n"
4902 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4903 Style);
4904
4905 Style.AllowAllParametersOfDeclarationOnNextLine = false;
4906 Style.AllowAllConstructorInitializersOnNextLine = false;
4907 verifyFormat("SomeClassWithALongName::Constructor(\n"
4908 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4909 " int bbbbbbbbbbbbb)\n"
4910 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
4911 " , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4912 Style);
4913
4914 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4915
4916 Style.AllowAllParametersOfDeclarationOnNextLine = true;
4917 verifyFormat("SomeClassWithALongName::Constructor(\n"
4918 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4919 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
4920 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4921 Style);
4922
4923 Style.AllowAllConstructorInitializersOnNextLine = true;
4924 verifyFormat("SomeClassWithALongName::Constructor(\n"
4925 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4926 " int bbbbbbbbbbbbb,\n"
4927 " int cccccccccccccccc)\n"
4928 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4929 Style);
4930
4931 Style.AllowAllParametersOfDeclarationOnNextLine = false;
4932 Style.AllowAllConstructorInitializersOnNextLine = false;
4933 verifyFormat("SomeClassWithALongName::Constructor(\n"
4934 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4935 " int bbbbbbbbbbbbb)\n"
4936 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
4937 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4938 Style);
4939
4940 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4941 Style.AllowAllParametersOfDeclarationOnNextLine = true;
4942 verifyFormat("SomeClassWithALongName::Constructor(\n"
4943 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4944 " aaaaaaaaaaaaaaaaaaaa(a),\n"
4945 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4946 Style);
4947
4948 Style.AllowAllConstructorInitializersOnNextLine = true;
4949 verifyFormat("SomeClassWithALongName::Constructor(\n"
4950 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4951 " int bbbbbbbbbbbbb,\n"
4952 " int cccccccccccccccc) :\n"
4953 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4954 Style);
4955
4956 Style.AllowAllParametersOfDeclarationOnNextLine = false;
4957 Style.AllowAllConstructorInitializersOnNextLine = false;
4958 verifyFormat("SomeClassWithALongName::Constructor(\n"
4959 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4960 " int bbbbbbbbbbbbb) :\n"
4961 " aaaaaaaaaaaaaaaaaaaa(a),\n"
4962 " bbbbbbbbbbbbbbbbbbbbb(b) {}",
4963 Style);
4964}
4965
4966TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4967 FormatStyle Style = getLLVMStyle();
4968 Style.ColumnLimit = 60;
4969 Style.BinPackArguments = false;
4970 for (int i = 0; i < 4; ++i) {
4971 // Test all combinations of parameters that should not have an effect.
4972 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4973 Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4974
4975 Style.AllowAllArgumentsOnNextLine = true;
4976 verifyFormat("void foo() {\n"
4977 " FunctionCallWithReallyLongName(\n"
4978 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4979 "}",
4980 Style);
4981 Style.AllowAllArgumentsOnNextLine = false;
4982 verifyFormat("void foo() {\n"
4983 " FunctionCallWithReallyLongName(\n"
4984 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4985 " bbbbbbbbbbbb);\n"
4986 "}",
4987 Style);
4988
4989 Style.AllowAllArgumentsOnNextLine = true;
4990 verifyFormat("void foo() {\n"
4991 " auto VariableWithReallyLongName = {\n"
4992 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4993 "}",
4994 Style);
4995 Style.AllowAllArgumentsOnNextLine = false;
4996 verifyFormat("void foo() {\n"
4997 " auto VariableWithReallyLongName = {\n"
4998 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4999 " bbbbbbbbbbbb};\n"
5000 "}",
5001 Style);
5002 }
5003
5004 // This parameter should not affect declarations.
5005 Style.BinPackParameters = false;
5006 Style.AllowAllArgumentsOnNextLine = false;
5007 Style.AllowAllParametersOfDeclarationOnNextLine = true;
5008 verifyFormat("void FunctionCallWithReallyLongName(\n"
5009 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
5010 Style);
5011 Style.AllowAllParametersOfDeclarationOnNextLine = false;
5012 verifyFormat("void FunctionCallWithReallyLongName(\n"
5013 " int aaaaaaaaaaaaaaaaaaaaaaa,\n"
5014 " int bbbbbbbbbbbb);",
5015 Style);
5016}
5017
5018TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) {
5019 // Check that AllowAllArgumentsOnNextLine is respected for both BAS_DontAlign
5020 // and BAS_Align.
5021 auto Style = getLLVMStyle();
5022 Style.ColumnLimit = 35;
5023 StringRef Input = "functionCall(paramA, paramB, paramC);\n"
5024 "void functionDecl(int A, int B, int C);";
5025 Style.AllowAllArgumentsOnNextLine = false;
5026 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5027 EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5028 " paramC);\n"
5029 "void functionDecl(int A, int B,\n"
5030 " int C);"),
5031 format(Input, Style));
5032 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5033 EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5034 " paramC);\n"
5035 "void functionDecl(int A, int B,\n"
5036 " int C);"),
5037 format(Input, Style));
5038 // However, BAS_AlwaysBreak should take precedence over
5039 // AllowAllArgumentsOnNextLine.
5040 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5041 EXPECT_EQ(StringRef("functionCall(\n"
5042 " paramA, paramB, paramC);\n"
5043 "void functionDecl(\n"
5044 " int A, int B, int C);"),
5045 format(Input, Style));
5046
5047 // When AllowAllArgumentsOnNextLine is set, we prefer breaking before the
5048 // first argument.
5049 Style.AllowAllArgumentsOnNextLine = true;
5050 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5051 EXPECT_EQ(StringRef("functionCall(\n"
5052 " paramA, paramB, paramC);\n"
5053 "void functionDecl(\n"
5054 " int A, int B, int C);"),
5055 format(Input, Style));
5056 // It wouldn't fit on one line with aligned parameters so this setting
5057 // doesn't change anything for BAS_Align.
5058 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5059 EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5060 " paramC);\n"
5061 "void functionDecl(int A, int B,\n"
5062 " int C);"),
5063 format(Input, Style));
5064 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5065 EXPECT_EQ(StringRef("functionCall(\n"
5066 " paramA, paramB, paramC);\n"
5067 "void functionDecl(\n"
5068 " int A, int B, int C);"),
5069 format(Input, Style));
5070}
5071
5072TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
5073 FormatStyle Style = getLLVMStyle();
5074 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
5075
5076 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5077 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
5078 getStyleWithColumns(Style, 45));
5079 verifyFormat("Constructor() :\n"
5080 " Initializer(FitsOnTheLine) {}",
5081 getStyleWithColumns(Style, 44));
5082 verifyFormat("Constructor() :\n"
5083 " Initializer(FitsOnTheLine) {}",
5084 getStyleWithColumns(Style, 43));
5085
5086 verifyFormat("template <typename T>\n"
5087 "Constructor() : Initializer(FitsOnTheLine) {}",
5088 getStyleWithColumns(Style, 50));
5089 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5090 verifyFormat(
5091 "SomeClass::Constructor() :\n"
5092 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5093 Style);
5094
5095 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
5096 verifyFormat(
5097 "SomeClass::Constructor() :\n"
5098 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5099 Style);
5100
5101 verifyFormat(
5102 "SomeClass::Constructor() :\n"
5103 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5104 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5105 Style);
5106 verifyFormat(
5107 "SomeClass::Constructor() :\n"
5108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5109 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5110 Style);
5111 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5112 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5113 " aaaaaaaaaa(aaaaaa) {}",
5114 Style);
5115
5116 verifyFormat("Constructor() :\n"
5117 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5118 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5119 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5120 " aaaaaaaaaaaaaaaaaaaaaaa() {}",
5121 Style);
5122
5123 verifyFormat("Constructor() :\n"
5124 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5125 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5126 Style);
5127
5128 verifyFormat("Constructor(int Parameter = 0) :\n"
5129 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5130 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5131 Style);
5132 verifyFormat("Constructor() :\n"
5133 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5134 "}",
5135 getStyleWithColumns(Style, 60));
5136 verifyFormat("Constructor() :\n"
5137 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5138 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5139 Style);
5140
5141 // Here a line could be saved by splitting the second initializer onto two
5142 // lines, but that is not desirable.
5143 verifyFormat("Constructor() :\n"
5144 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5145 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
5146 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5147 Style);
5148
5149 FormatStyle OnePerLine = Style;
5150 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5151 OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5152 verifyFormat("SomeClass::Constructor() :\n"
5153 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5154 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5155 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5156 OnePerLine);
5157 verifyFormat("SomeClass::Constructor() :\n"
5158 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5159 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5160 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5161 OnePerLine);
5162 verifyFormat("MyClass::MyClass(int var) :\n"
5163 " some_var_(var), // 4 space indent\n"
5164 " some_other_var_(var + 1) { // lined up\n"
5165 "}",
5166 OnePerLine);
5167 verifyFormat("Constructor() :\n"
5168 " aaaaa(aaaaaa),\n"
5169 " aaaaa(aaaaaa),\n"
5170 " aaaaa(aaaaaa),\n"
5171 " aaaaa(aaaaaa),\n"
5172 " aaaaa(aaaaaa) {}",
5173 OnePerLine);
5174 verifyFormat("Constructor() :\n"
5175 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5176 " aaaaaaaaaaaaaaaaaaaaaa) {}",
5177 OnePerLine);
5178 OnePerLine.BinPackParameters = false;
5179 verifyFormat("Constructor() :\n"
5180 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5181 " aaaaaaaaaaa().aaa(),\n"
5182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5183 OnePerLine);
5184 OnePerLine.ColumnLimit = 60;
5185 verifyFormat("Constructor() :\n"
5186 " aaaaaaaaaaaaaaaaaaaa(a),\n"
5187 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5188 OnePerLine);
5189
5190 EXPECT_EQ("Constructor() :\n"
5191 " // Comment forcing unwanted break.\n"
5192 " aaaa(aaaa) {}",
5193 format("Constructor() :\n"
5194 " // Comment forcing unwanted break.\n"
5195 " aaaa(aaaa) {}",
5196 Style));
5197
5198 Style.ColumnLimit = 0;
5199 verifyFormat("SomeClass::Constructor() :\n"
5200 " a(a) {}",
5201 Style);
5202 verifyFormat("SomeClass::Constructor() noexcept :\n"
5203 " a(a) {}",
5204 Style);
5205 verifyFormat("SomeClass::Constructor() :\n"
5206 " a(a), b(b), c(c) {}",
5207 Style);
5208 verifyFormat("SomeClass::Constructor() :\n"
5209 " a(a) {\n"
5210 " foo();\n"
5211 " bar();\n"
5212 "}",
5213 Style);
5214
5215 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5216 verifyFormat("SomeClass::Constructor() :\n"
5217 " a(a), b(b), c(c) {\n"
5218 "}",
5219 Style);
5220 verifyFormat("SomeClass::Constructor() :\n"
5221 " a(a) {\n"
5222 "}",
5223 Style);
5224
5225 Style.ColumnLimit = 80;
5226 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5227 Style.ConstructorInitializerIndentWidth = 2;
5228 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5229 verifyFormat("SomeClass::Constructor() :\n"
5230 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5231 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5232 Style);
5233
5234 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5235 // well
5236 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5237 verifyFormat(
5238 "class SomeClass\n"
5239 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5240 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5241 Style);
5242 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5243 verifyFormat(
5244 "class SomeClass\n"
5245 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5246 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5247 Style);
5248 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5249 verifyFormat(
5250 "class SomeClass :\n"
5251 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5252 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5253 Style);
5254}
5255
5256#ifndef EXPENSIVE_CHECKS
5257// Expensive checks enables libstdc++ checking which includes validating the
5258// state of ranges used in std::priority_queue - this blows out the
5259// runtime/scalability of the function and makes this test unacceptably slow.
5260TEST_F(FormatTest, MemoizationTests) {
5261 // This breaks if the memoization lookup does not take \c Indent and
5262 // \c LastSpace into account.
5263 verifyFormat(
5264 "extern CFRunLoopTimerRef\n"
5265 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5266 " CFTimeInterval interval, CFOptionFlags flags,\n"
5267 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
5268 " CFRunLoopTimerContext *context) {}");
5269
5270 // Deep nesting somewhat works around our memoization.
5271 verifyFormat(
5272 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5273 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5274 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5275 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5276 " aaaaa())))))))))))))))))))))))))))))))))))))));",
5277 getLLVMStyleWithColumns(65));
5278 verifyFormat(
5279 "aaaaa(\n"
5280 " aaaaa,\n"
5281 " aaaaa(\n"
5282 " aaaaa,\n"
5283 " aaaaa(\n"
5284 " aaaaa,\n"
5285 " aaaaa(\n"
5286 " aaaaa,\n"
5287 " aaaaa(\n"
5288 " aaaaa,\n"
5289 " aaaaa(\n"
5290 " aaaaa,\n"
5291 " aaaaa(\n"
5292 " aaaaa,\n"
5293 " aaaaa(\n"
5294 " aaaaa,\n"
5295 " aaaaa(\n"
5296 " aaaaa,\n"
5297 " aaaaa(\n"
5298 " aaaaa,\n"
5299 " aaaaa(\n"
5300 " aaaaa,\n"
5301 " aaaaa(\n"
5302 " aaaaa,\n"
5303 " aaaaa))))))))))));",
5304 getLLVMStyleWithColumns(65));
5305 verifyFormat(
5306 "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
5307 " a),\n"
5308 " a),\n"
5309 " a),\n"
5310 " a),\n"
5311 " a),\n"
5312 " a),\n"
5313 " a),\n"
5314 " a),\n"
5315 " a),\n"
5316 " a),\n"
5317 " a),\n"
5318 " a),\n"
5319 " a),\n"
5320 " a),\n"
5321 " a),\n"
5322 " a),\n"
5323 " a)",
5324 getLLVMStyleWithColumns(65));
5325
5326 // This test takes VERY long when memoization is broken.
5327 FormatStyle OnePerLine = getLLVMStyle();
5328 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5329 OnePerLine.BinPackParameters = false;
5330 std::string input = "Constructor()\n"
5331 " : aaaa(a,\n";
5332 for (unsigned i = 0, e = 80; i != e; ++i) {
5333 input += " a,\n";
5334 }
5335 input += " a) {}";
5336 verifyFormat(input, OnePerLine);
5337}
5338#endif
5339
5340TEST_F(FormatTest, BreaksAsHighAsPossible) {
5341 verifyFormat(
5342 "void f() {\n"
5343 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5344 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5345 " f();\n"
5346 "}");
5347 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5348 " Intervals[i - 1].getRange().getLast()) {\n}");
5349}
5350
5351TEST_F(FormatTest, BreaksFunctionDeclarations) {
5352 // Principially, we break function declarations in a certain order:
5353 // 1) break amongst arguments.
5354 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5355 " Cccccccccccccc cccccccccccccc);");
5356 verifyFormat("template <class TemplateIt>\n"
5357 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5358 " TemplateIt *stop) {}");
5359
5360 // 2) break after return type.
5361 verifyFormat(
5362 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5363 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5364 getGoogleStyle());
5365
5366 // 3) break after (.
5367 verifyFormat(
5368 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5369 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5370 getGoogleStyle());
5371
5372 // 4) break before after nested name specifiers.
5373 verifyFormat(
5374 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5375 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5376 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5377 getGoogleStyle());
5378
5379 // However, there are exceptions, if a sufficient amount of lines can be
5380 // saved.
5381 // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5382 // more adjusting.
5383 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5384 " Cccccccccccccc cccccccccc,\n"
5385 " Cccccccccccccc cccccccccc,\n"
5386 " Cccccccccccccc cccccccccc,\n"
5387 " Cccccccccccccc cccccccccc);");
5388 verifyFormat(
5389 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5390 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5391 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5392 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5393 getGoogleStyle());
5394 verifyFormat(
5395 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5396 " Cccccccccccccc cccccccccc,\n"
5397 " Cccccccccccccc cccccccccc,\n"
5398 " Cccccccccccccc cccccccccc,\n"
5399 " Cccccccccccccc cccccccccc,\n"
5400 " Cccccccccccccc cccccccccc,\n"
5401 " Cccccccccccccc cccccccccc);");
5402 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5403 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5404 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5405 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5406 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5407
5408 // Break after multi-line parameters.
5409 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5410 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5412 " bbbb bbbb);");
5413 verifyFormat("void SomeLoooooooooooongFunction(\n"
5414 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5415 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5416 " int bbbbbbbbbbbbb);");
5417
5418 // Treat overloaded operators like other functions.
5419 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5420 "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5421 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5422 "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5423 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5424 "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5425 verifyGoogleFormat(
5426 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5427 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5428 verifyGoogleFormat(
5429 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5430 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5431 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5432 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5433 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5434 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5435 verifyGoogleFormat(
5436 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5437 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5438 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5439 verifyGoogleFormat("template <typename T>\n"
5440 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5441 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5442 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5443
5444 FormatStyle Style = getLLVMStyle();
5445 Style.PointerAlignment = FormatStyle::PAS_Left;
5446 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5447 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5448 Style);
5449 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5451 Style);
5452}
5453
5454TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5455 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5456 // Prefer keeping `::` followed by `operator` together.
5457 EXPECT_EQ("const aaaa::bbbbbbb &\n"
5458 "ccccccccc::operator++() {\n"
5459 " stuff();\n"
5460 "}",
5461 format("const aaaa::bbbbbbb\n"
5462 "&ccccccccc::operator++() { stuff(); }",
5463 getLLVMStyleWithColumns(40)));
5464}
5465
5466TEST_F(FormatTest, TrailingReturnType) {
5467 verifyFormat("auto foo() -> int;\n");
5468 // correct trailing return type spacing
5469 verifyFormat("auto operator->() -> int;\n");
5470 verifyFormat("auto operator++(int) -> int;\n");
5471
5472 verifyFormat("struct S {\n"
5473 " auto bar() const -> int;\n"
5474 "};");
5475 verifyFormat("template <size_t Order, typename T>\n"
5476 "auto load_img(const std::string &filename)\n"
5477 " -> alias::tensor<Order, T, mem::tag::cpu> {}");
5478 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5479 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5480 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5481 verifyFormat("template <typename T>\n"
5482 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5483 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5484
5485 // Not trailing return types.
5486 verifyFormat("void f() { auto a = b->c(); }");
5487}
5488
5489TEST_F(FormatTest, DeductionGuides) {
5490 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5491 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5492 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5493 verifyFormat(
5494 "template <class... T>\n"
5495 "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5496 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5497 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5498 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5499 verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5500 verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5501 verifyFormat("template <class T> x() -> x<1>;");
5502 verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5503
5504 // Ensure not deduction guides.
5505 verifyFormat("c()->f<int>();");
5506 verifyFormat("x()->foo<1>;");
5507 verifyFormat("x = p->foo<3>();");
5508 verifyFormat("x()->x<1>();");
5509 verifyFormat("x()->x<1>;");
5510}
5511
5512TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5513 // Avoid breaking before trailing 'const' or other trailing annotations, if
5514 // they are not function-like.
5515 FormatStyle Style = getGoogleStyle();
5516 Style.ColumnLimit = 47;
5517 verifyFormat("void someLongFunction(\n"
5518 " int someLoooooooooooooongParameter) const {\n}",
5519 getLLVMStyleWithColumns(47));
5520 verifyFormat("LoooooongReturnType\n"
5521 "someLoooooooongFunction() const {}",
5522 getLLVMStyleWithColumns(47));
5523 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5524 " const {}",
5525 Style);
5526 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5527 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5528 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5529 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5530 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5531 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5532 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5533 " aaaaaaaaaaa aaaaa) const override;");
5534 verifyGoogleFormat(
5535 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5536 " const override;");
5537
5538 // Even if the first parameter has to be wrapped.
5539 verifyFormat("void someLongFunction(\n"
5540 " int someLongParameter) const {}",
5541 getLLVMStyleWithColumns(46));
5542 verifyFormat("void someLongFunction(\n"
5543 " int someLongParameter) const {}",
5544 Style);
5545 verifyFormat("void someLongFunction(\n"
5546 " int someLongParameter) override {}",
5547 Style);
5548 verifyFormat("void someLongFunction(\n"
5549 " int someLongParameter) OVERRIDE {}",
5550 Style);
5551 verifyFormat("void someLongFunction(\n"
5552 " int someLongParameter) final {}",
5553 Style);
5554 verifyFormat("void someLongFunction(\n"
5555 " int someLongParameter) FINAL {}",
5556 Style);
5557 verifyFormat("void someLongFunction(\n"
5558 " int parameter) const override {}",
5559 Style);
5560
5561 Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5562 verifyFormat("void someLongFunction(\n"
5563 " int someLongParameter) const\n"
5564 "{\n"
5565 "}",
5566 Style);
5567
5568 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5569 verifyFormat("void someLongFunction(\n"
5570 " int someLongParameter) const\n"
5571 " {\n"
5572 " }",
5573 Style);
5574
5575 // Unless these are unknown annotations.
5576 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5577 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5578 " LONG_AND_UGLY_ANNOTATION;");
5579
5580 // Breaking before function-like trailing annotations is fine to keep them
5581 // close to their arguments.
5582 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5583 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5584 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5585 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5586 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5587 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5588 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5589 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5590 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5591
5592 verifyFormat(
5593 "void aaaaaaaaaaaaaaaaaa()\n"
5594 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5595 " aaaaaaaaaaaaaaaaaaaaaaaaa));");
5596 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5597 " __attribute__((unused));");
5598 verifyGoogleFormat(
5599 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5600 " GUARDED_BY(aaaaaaaaaaaa);");
5601 verifyGoogleFormat(
5602 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5603 " GUARDED_BY(aaaaaaaaaaaa);");
5604 verifyGoogleFormat(
5605 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5606 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5607 verifyGoogleFormat(
5608 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5609 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
5610}
5611
5612TEST_F(FormatTest, FunctionAnnotations) {
5613 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5614 "int OldFunction(const string &parameter) {}");
5615 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5616 "string OldFunction(const string &parameter) {}");
5617 verifyFormat("template <typename T>\n"
5618 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5619 "string OldFunction(const string &parameter) {}");
5620
5621 // Not function annotations.
5622 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5623 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5624 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5625 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5626 verifyFormat("MACRO(abc).function() // wrap\n"
5627 " << abc;");
5628 verifyFormat("MACRO(abc)->function() // wrap\n"
5629 " << abc;");
5630 verifyFormat("MACRO(abc)::function() // wrap\n"
5631 " << abc;");
5632}
5633
5634TEST_F(FormatTest, BreaksDesireably) {
5635 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5636 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5637 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5638 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5639 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5640 "}");
5641
5642 verifyFormat(
5643 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5644 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5645
5646 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5649
5650 verifyFormat(
5651 "aaaaaaaa(aaaaaaaaaaaaa,\n"
5652 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5653 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5654 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5656
5657 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5658 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5659
5660 verifyFormat(
5661 "void f() {\n"
5662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5664 "}");
5665 verifyFormat(
5666 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5668 verifyFormat(
5669 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5671 verifyFormat(
5672 "aaaaaa(aaa,\n"
5673 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5675 " aaaa);");
5676 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5678 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5679
5680 // Indent consistently independent of call expression and unary operator.
5681 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5682 " dddddddddddddddddddddddddddddd));");
5683 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5684 " dddddddddddddddddddddddddddddd));");
5685 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5686 " dddddddddddddddddddddddddddddd));");
5687
5688 // This test case breaks on an incorrect memoization, i.e. an optimization not
5689 // taking into account the StopAt value.
5690 verifyFormat(
5691 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5692 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5693 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5694 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5695
5696 verifyFormat("{\n {\n {\n"
5697 " Annotation.SpaceRequiredBefore =\n"
5698 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5699 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5700 " }\n }\n}");
5701
5702 // Break on an outer level if there was a break on an inner level.
5703 EXPECT_EQ("f(g(h(a, // comment\n"
5704 " b, c),\n"
5705 " d, e),\n"
5706 " x, y);",
5707 format("f(g(h(a, // comment\n"
5708 " b, c), d, e), x, y);"));
5709
5710 // Prefer breaking similar line breaks.
5711 verifyFormat(
5712 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5713 " NSTrackingMouseEnteredAndExited |\n"
5714 " NSTrackingActiveAlways;");
5715}
5716
5717TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5718 FormatStyle NoBinPacking = getGoogleStyle();
5719 NoBinPacking.BinPackParameters = false;
5720 NoBinPacking.BinPackArguments = true;
5721 verifyFormat("void f() {\n"
5722 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5724 "}",
5725 NoBinPacking);
5726 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5727 " int aaaaaaaaaaaaaaaaaaaa,\n"
5728 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5729 NoBinPacking);
5730
5731 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5732 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5733 " vector<int> bbbbbbbbbbbbbbb);",
5734 NoBinPacking);
5735 // FIXME: This behavior difference is probably not wanted. However, currently
5736 // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5737 // template arguments from BreakBeforeParameter being set because of the
5738 // one-per-line formatting.
5739 verifyFormat(
5740 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5741 " aaaaaaaaaa> aaaaaaaaaa);",
5742 NoBinPacking);
5743 verifyFormat(
5744 "void fffffffffff(\n"
5745 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5746 " aaaaaaaaaa);");
5747}
5748
5749TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5750 FormatStyle NoBinPacking = getGoogleStyle();
5751 NoBinPacking.BinPackParameters = false;
5752 NoBinPacking.BinPackArguments = false;
5753 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5754 " aaaaaaaaaaaaaaaaaaaa,\n"
5755 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5756 NoBinPacking);
5757 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5758 " aaaaaaaaaaaaa,\n"
5759 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5760 NoBinPacking);
5761 verifyFormat(
5762 "aaaaaaaa(aaaaaaaaaaaaa,\n"
5763 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5765 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5766 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5767 NoBinPacking);
5768 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5769 " .aaaaaaaaaaaaaaaaaa();",
5770 NoBinPacking);
5771 verifyFormat("void f() {\n"
5772 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5773 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5774 "}",
5775 NoBinPacking);
5776
5777 verifyFormat(
5778 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5779 " aaaaaaaaaaaa,\n"
5780 " aaaaaaaaaaaa);",
5781 NoBinPacking);
5782 verifyFormat(
5783 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5784 " ddddddddddddddddddddddddddddd),\n"
5785 " test);",
5786 NoBinPacking);
5787
5788 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5789 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
5790 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
5791 " aaaaaaaaaaaaaaaaaa;",
5792 NoBinPacking);
5793 verifyFormat("a(\"a\"\n"
5794 " \"a\",\n"
5795 " a);");
5796
5797 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5798 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5799 " aaaaaaaaa,\n"
5800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5801 NoBinPacking);
5802 verifyFormat(
5803 "void f() {\n"
5804 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5805 " .aaaaaaa();\n"
5806 "}",
5807 NoBinPacking);
5808 verifyFormat(
5809 "template <class SomeType, class SomeOtherType>\n"
5810 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5811 NoBinPacking);
5812}
5813
5814TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5815 FormatStyle Style = getLLVMStyleWithColumns(15);
5816 Style.ExperimentalAutoDetectBinPacking = true;
5817 EXPECT_EQ("aaa(aaaa,\n"
5818 " aaaa,\n"
5819 " aaaa);\n"
5820 "aaa(aaaa,\n"
5821 " aaaa,\n"
5822 " aaaa);",
5823 format("aaa(aaaa,\n" // one-per-line
5824 " aaaa,\n"
5825 " aaaa );\n"
5826 "aaa(aaaa, aaaa, aaaa);", // inconclusive
5827 Style));
5828 EXPECT_EQ("aaa(aaaa, aaaa,\n"
5829 " aaaa);\n"
5830 "aaa(aaaa, aaaa,\n"
5831 " aaaa);",
5832 format("aaa(aaaa, aaaa,\n" // bin-packed
5833 " aaaa );\n"
5834 "aaa(aaaa, aaaa, aaaa);", // inconclusive
5835 Style));
5836}
5837
5838TEST_F(FormatTest, FormatsBuilderPattern) {
5839 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5840 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5841 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5842 " .StartsWith(\".init\", ORDER_INIT)\n"
5843 " .StartsWith(\".fini\", ORDER_FINI)\n"
5844 " .StartsWith(\".hash\", ORDER_HASH)\n"
5845 " .Default(ORDER_TEXT);\n");
5846
5847 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5848 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5849 verifyFormat("aaaaaaa->aaaaaaa\n"
5850 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5851 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5852 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5853 verifyFormat(
5854 "aaaaaaa->aaaaaaa\n"
5855 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5856 " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5857 verifyFormat(
5858 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5859 " aaaaaaaaaaaaaa);");
5860 verifyFormat(
5861 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5862 " aaaaaa->aaaaaaaaaaaa()\n"
5863 " ->aaaaaaaaaaaaaaaa(\n"
5864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5865 " ->aaaaaaaaaaaaaaaaa();");
5866 verifyGoogleFormat(
5867 "void f() {\n"
5868 " someo->Add((new util::filetools::Handler(dir))\n"
5869 " ->OnEvent1(NewPermanentCallback(\n"
5870 " this, &HandlerHolderClass::EventHandlerCBA))\n"
5871 " ->OnEvent2(NewPermanentCallback(\n"
5872 " this, &HandlerHolderClass::EventHandlerCBB))\n"
5873 " ->OnEvent3(NewPermanentCallback(\n"
5874 " this, &HandlerHolderClass::EventHandlerCBC))\n"
5875 " ->OnEvent5(NewPermanentCallback(\n"
5876 " this, &HandlerHolderClass::EventHandlerCBD))\n"
5877 " ->OnEvent6(NewPermanentCallback(\n"
5878 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
5879 "}");
5880
5881 verifyFormat(
5882 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5883 verifyFormat("aaaaaaaaaaaaaaa()\n"
5884 " .aaaaaaaaaaaaaaa()\n"
5885 " .aaaaaaaaaaaaaaa()\n"
5886 " .aaaaaaaaaaaaaaa()\n"
5887 " .aaaaaaaaaaaaaaa();");
5888 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5889 " .aaaaaaaaaaaaaaa()\n"
5890 " .aaaaaaaaaaaaaaa()\n"
5891 " .aaaaaaaaaaaaaaa();");
5892 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5893 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5894 " .aaaaaaaaaaaaaaa();");
5895 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5896 " ->aaaaaaaaaaaaaae(0)\n"
5897 " ->aaaaaaaaaaaaaaa();");
5898
5899 // Don't linewrap after very short segments.
5900 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5901 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5902 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5903 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5904 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5905 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5906 verifyFormat("aaa()\n"
5907 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5908 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5909 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5910
5911 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5912 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5913 " .has<bbbbbbbbbbbbbbbbbbbbb>();");
5914 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5915 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5916 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5917
5918 // Prefer not to break after empty parentheses.
5919 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5920 " First->LastNewlineOffset);");
5921
5922 // Prefer not to create "hanging" indents.
5923 verifyFormat(
5924 "return !soooooooooooooome_map\n"
5925 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5926 " .second;");
5927 verifyFormat(
5928 "return aaaaaaaaaaaaaaaa\n"
5929 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5930 " .aaaa(aaaaaaaaaaaaaa);");
5931 // No hanging indent here.
5932 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5934 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5936 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5937 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5938 getLLVMStyleWithColumns(60));
5939 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5940 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5941 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5942 getLLVMStyleWithColumns(59));
5943 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5944 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5945 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5946
5947 // Dont break if only closing statements before member call
5948 verifyFormat("test() {\n"
5949 " ([]() -> {\n"
5950 " int b = 32;\n"
5951 " return 3;\n"
5952 " }).foo();\n"
5953 "}");
5954 verifyFormat("test() {\n"
5955 " (\n"
5956 " []() -> {\n"
5957 " int b = 32;\n"
5958 " return 3;\n"
5959 " },\n"
5960 " foo, bar)\n"
5961 " .foo();\n"
5962 "}");
5963 verifyFormat("test() {\n"
5964 " ([]() -> {\n"
5965 " int b = 32;\n"
5966 " return 3;\n"
5967 " })\n"
5968 " .foo()\n"
5969 " .bar();\n"
5970 "}");
5971 verifyFormat("test() {\n"
5972 " ([]() -> {\n"
5973 " int b = 32;\n"
5974 " return 3;\n"
5975 " })\n"
5976 " .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5977 " \"bbbb\");\n"
5978 "}",
5979 getLLVMStyleWithColumns(30));
5980}
5981
5982TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5983 verifyFormat(
5984 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5985 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5986 verifyFormat(
5987 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5988 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5989
5990 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5991 " ccccccccccccccccccccccccc) {\n}");
5992 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5993 " ccccccccccccccccccccccccc) {\n}");
5994
5995 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5996 " ccccccccccccccccccccccccc) {\n}");
5997 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5998 " ccccccccccccccccccccccccc) {\n}");
5999
6000 verifyFormat(
6001 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
6002 " ccccccccccccccccccccccccc) {\n}");
6003 verifyFormat(
6004 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
6005 " ccccccccccccccccccccccccc) {\n}");
6006
6007 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
6008 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
6009 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
6010 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
6011 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
6012 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
6013 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
6014 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
6015
6016 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
6017 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
6018 " aaaaaaaaaaaaaaa != aa) {\n}");
6019 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
6020 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
6021 " aaaaaaaaaaaaaaa != aa) {\n}");
6022}
6023
6024TEST_F(FormatTest, BreaksAfterAssignments) {
6025 verifyFormat(
6026 "unsigned Cost =\n"
6027 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
6028 " SI->getPointerAddressSpaceee());\n");
6029 verifyFormat(
6030 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
6031 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
6032
6033 verifyFormat(
6034 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
6035 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
6036 verifyFormat("unsigned OriginalStartColumn =\n"
6037 " SourceMgr.getSpellingColumnNumber(\n"
6038 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
6039 " 1;");
6040}
6041
6042TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
6043 FormatStyle Style = getLLVMStyle();
6044 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6045 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
6046 Style);
6047
6048 Style.PenaltyBreakAssignment = 20;
6049 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
6050 " cccccccccccccccccccccccccc;",
6051 Style);
6052}
6053
6054TEST_F(FormatTest, AlignsAfterAssignments) {
6055 verifyFormat(
6056 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6057 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
6058 verifyFormat(
6059 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6060 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
6061 verifyFormat(
6062 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6063 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
6064 verifyFormat(
6065 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6066 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
6067 verifyFormat(
6068 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6069 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6070 " aaaaaaaaaaaaaaaaaaaaaaaa;");
6071}
6072
6073TEST_F(FormatTest, AlignsAfterReturn) {
6074 verifyFormat(
6075 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6076 " aaaaaaaaaaaaaaaaaaaaaaaaa;");
6077 verifyFormat(
6078 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6079 " aaaaaaaaaaaaaaaaaaaaaaaaa);");
6080 verifyFormat(
6081 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6082 " aaaaaaaaaaaaaaaaaaaaaa();");
6083 verifyFormat(
6084 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6085 " aaaaaaaaaaaaaaaaaaaaaa());");
6086 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6088 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
6090 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6091 verifyFormat("return\n"
6092 " // true if code is one of a or b.\n"
6093 " code == a || code == b;");
6094}
6095
6096TEST_F(FormatTest, AlignsAfterOpenBracket) {
6097 verifyFormat(
6098 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6099 " aaaaaaaaa aaaaaaa) {}");
6100 verifyFormat(
6101 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6102 " aaaaaaaaaaa aaaaaaaaa);");
6103 verifyFormat(
6104 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6105 " aaaaaaaaaaaaaaaaaaaaa));");
6106 FormatStyle Style = getLLVMStyle();
6107 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6108 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6109 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
6110 Style);
6111 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6112 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6113 Style);
6114 verifyFormat("SomeLongVariableName->someFunction(\n"
6115 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6116 Style);
6117 verifyFormat(
6118 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6119 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6120 Style);
6121 verifyFormat(
6122 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6123 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6124 Style);
6125 verifyFormat(
6126 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6127 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6128 Style);
6129
6130 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6131 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
6132 " b));",
6133 Style);
6134
6135 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6136 Style.BinPackArguments = false;
6137 Style.BinPackParameters = false;
6138 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6139 " aaaaaaaaaaa aaaaaaaa,\n"
6140 " aaaaaaaaa aaaaaaa,\n"
6141 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6142 Style);
6143 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6144 " aaaaaaaaaaa aaaaaaaaa,\n"
6145 " aaaaaaaaaaa aaaaaaaaa,\n"
6146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6147 Style);
6148 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6149 " aaaaaaaaaaaaaaa,\n"
6150 " aaaaaaaaaaaaaaaaaaaaa,\n"
6151 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6152 Style);
6153 verifyFormat(
6154 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6155 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6156 Style);
6157 verifyFormat(
6158 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6159 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6160 Style);
6161 verifyFormat(
6162 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6163 " aaaaaaaaaaaaaaaaaaaaa(\n"
6164 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6165 " aaaaaaaaaaaaaaaa);",
6166 Style);
6167 verifyFormat(
6168 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6169 " aaaaaaaaaaaaaaaaaaaaa(\n"
6170 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6171 " aaaaaaaaaaaaaaaa);",
6172 Style);
6173}
6174
6175TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6176 FormatStyle Style = getLLVMStyleWithColumns(40);
6177 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6178 " bbbbbbbbbbbbbbbbbbbbbb);",
6179 Style);
6180 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6181 Style.AlignOperands = FormatStyle::OAS_DontAlign;
6182 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6183 " bbbbbbbbbbbbbbbbbbbbbb);",
6184 Style);
6185 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6186 Style.AlignOperands = FormatStyle::OAS_Align;
6187 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6188 " bbbbbbbbbbbbbbbbbbbbbb);",
6189 Style);
6190 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6191 Style.AlignOperands = FormatStyle::OAS_DontAlign;
6192 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6193 " bbbbbbbbbbbbbbbbbbbbbb);",
6194 Style);
6195}
6196
6197TEST_F(FormatTest, BreaksConditionalExpressions) {
6198 verifyFormat(
6199 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6200 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6201 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6202 verifyFormat(
6203 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6204 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6205 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6206 verifyFormat(
6207 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6208 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6209 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6210 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6211 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6212 verifyFormat(
6213 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6214 " : aaaaaaaaaaaaa);");
6215 verifyFormat(
6216 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6217 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6218 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6219 " aaaaaaaaaaaaa);");
6220 verifyFormat(
6221 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6222 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6223 " aaaaaaaaaaaaa);");
6224 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6225 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6226 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6227 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6228 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6229 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6230 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6231 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6233 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6234 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6235 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6236 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6237 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6238 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6239 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6240 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6241 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6242 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6243 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6244 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6245 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6246 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6247 " : aaaaaaaaaaaaaaaa;");
6248 verifyFormat(
6249 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6250 " ? aaaaaaaaaaaaaaa\n"
6251 " : aaaaaaaaaaaaaaa;");
6252 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6253 " aaaaaaaaa\n"
6254 " ? b\n"
6255 " : c);");
6256 verifyFormat("return aaaa == bbbb\n"
6257 " // comment\n"
6258 " ? aaaa\n"
6259 " : bbbb;");
6260 verifyFormat("unsigned Indent =\n"
6261 " format(TheLine.First,\n"
6262 " IndentForLevel[TheLine.Level] >= 0\n"
6263 " ? IndentForLevel[TheLine.Level]\n"
6264 " : TheLine * 2,\n"
6265 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
6266 getLLVMStyleWithColumns(60));
6267 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6268 " ? aaaaaaaaaaaaaaa\n"
6269 " : bbbbbbbbbbbbbbb //\n"
6270 " ? ccccccccccccccc\n"
6271 " : ddddddddddddddd;");
6272 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6273 " ? aaaaaaaaaaaaaaa\n"
6274 " : (bbbbbbbbbbbbbbb //\n"
6275 " ? ccccccccccccccc\n"
6276 " : ddddddddddddddd);");
6277 verifyFormat(
6278 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6279 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6280 " aaaaaaaaaaaaaaaaaaaaa +\n"
6281 " aaaaaaaaaaaaaaaaaaaaa\n"
6282 " : aaaaaaaaaa;");
6283 verifyFormat(
6284 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6285 " : aaaaaaaaaaaaaaaaaaaaaa\n"
6286 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6287
6288 FormatStyle NoBinPacking = getLLVMStyle();
6289 NoBinPacking.BinPackArguments = false;
6290 verifyFormat(
6291 "void f() {\n"
6292 " g(aaa,\n"
6293 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6295 " ? aaaaaaaaaaaaaaa\n"
6296 " : aaaaaaaaaaaaaaa);\n"
6297 "}",
6298 NoBinPacking);
6299 verifyFormat(
6300 "void f() {\n"
6301 " g(aaa,\n"
6302 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6303 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6304 " ?: aaaaaaaaaaaaaaa);\n"
6305 "}",
6306 NoBinPacking);
6307
6308 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6309 " // comment.\n"
6310 " ccccccccccccccccccccccccccccccccccccccc\n"
6311 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6312 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6313
6314 // Assignments in conditional expressions. Apparently not uncommon :-(.
6315 verifyFormat("return a != b\n"
6316 " // comment\n"
6317 " ? a = b\n"
6318 " : a = b;");
6319 verifyFormat("return a != b\n"
6320 " // comment\n"
6321 " ? a = a != b\n"
6322 " // comment\n"
6323 " ? a = b\n"
6324 " : a\n"
6325 " : a;\n");
6326 verifyFormat("return a != b\n"
6327 " // comment\n"
6328 " ? a\n"
6329 " : a = a != b\n"
6330 " // comment\n"
6331 " ? a = b\n"
6332 " : a;");
6333
6334 // Chained conditionals
6335 FormatStyle Style = getLLVMStyle();
6336 Style.ColumnLimit = 70;
6337 Style.AlignOperands = FormatStyle::OAS_Align;
6338 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6339 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6340 " : 3333333333333333;",
6341 Style);
6342 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6343 " : bbbbbbbbbb ? 2222222222222222\n"
6344 " : 3333333333333333;",
6345 Style);
6346 verifyFormat("return aaaaaaaaaa ? 1111111111111111\n"
6347 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6348 " : 3333333333333333;",
6349 Style);
6350 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6351 " : bbbbbbbbbbbbbb ? 222222\n"
6352 " : 333333;",
6353 Style);
6354 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6355 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6356 " : cccccccccccccc ? 3333333333333333\n"
6357 " : 4444444444444444;",
6358 Style);
6359 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6360 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6361 " : 3333333333333333;",
6362 Style);
6363 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6364 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6365 " : (aaa ? bbb : ccc);",
6366 Style);
6367 verifyFormat(
6368 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6369 " : cccccccccccccccccc)\n"
6370 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6371 " : 3333333333333333;",
6372 Style);
6373 verifyFormat(
6374 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6375 " : cccccccccccccccccc)\n"
6376 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6377 " : 3333333333333333;",
6378 Style);
6379 verifyFormat(
6380 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6381 " : dddddddddddddddddd)\n"
6382 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6383 " : 3333333333333333;",
6384 Style);
6385 verifyFormat(
6386 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6387 " : dddddddddddddddddd)\n"
6388 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6389 " : 3333333333333333;",
6390 Style);
6391 verifyFormat(
6392 "return aaaaaaaaa ? 1111111111111111\n"
6393 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6394 " : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6395 " : dddddddddddddddddd)\n",
6396 Style);
6397 verifyFormat(
6398 "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6399 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6400 " : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6401 " : cccccccccccccccccc);",
6402 Style);
6403 verifyFormat(
6404 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6405 " : ccccccccccccccc ? dddddddddddddddddd\n"
6406 " : eeeeeeeeeeeeeeeeee)\n"
6407 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6408 " : 3333333333333333;",
6409 Style);
6410 verifyFormat(
6411 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6412 " : ccccccccccccccc ? dddddddddddddddddd\n"
6413 " : eeeeeeeeeeeeeeeeee)\n"
6414 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6415 " : 3333333333333333;",
6416 Style);
6417 verifyFormat(
6418 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6419 " : cccccccccccc ? dddddddddddddddddd\n"
6420 " : eeeeeeeeeeeeeeeeee)\n"
6421 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6422 " : 3333333333333333;",
6423 Style);
6424 verifyFormat(
6425 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6426 " : cccccccccccccccccc\n"
6427 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6428 " : 3333333333333333;",
6429 Style);
6430 verifyFormat(
6431 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6432 " : cccccccccccccccc ? dddddddddddddddddd\n"
6433 " : eeeeeeeeeeeeeeeeee\n"
6434 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
6435 " : 3333333333333333;",
6436 Style);
6437 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6438 " ? (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6439 " : cccccccccccccccccc ? dddddddddddddddddd\n"
6440 " : eeeeeeeeeeeeeeeeee)\n"
6441 " : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6442 " : 3333333333333333;",
6443 Style);
6444 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6445 " ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6446 " : cccccccccccccccc ? dddddddddddddddddd\n"
6447 " : eeeeeeeeeeeeeeeeee\n"
6448 " : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6449 " : 3333333333333333;",
6450 Style);
6451
6452 Style.AlignOperands = FormatStyle::OAS_DontAlign;
6453 Style.BreakBeforeTernaryOperators = false;
6454 // FIXME: Aligning the question marks is weird given DontAlign.
6455 // Consider disabling this alignment in this case. Also check whether this
6456 // will render the adjustment from https://reviews.llvm.org/D82199
6457 // unnecessary.
6458 verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6459 " bbbb ? cccccccccccccccccc :\n"
6460 " ddddd;\n",
6461 Style);
6462}
6463
6464TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6465 FormatStyle Style = getLLVMStyle();
6466 Style.BreakBeforeTernaryOperators = false;
6467 Style.ColumnLimit = 70;
6468 verifyFormat(
6469 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6472 Style);
6473 verifyFormat(
6474 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6475 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6476 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6477 Style);
6478 verifyFormat(
6479 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6480 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6481 Style);
6482 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6483 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6484 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6485 Style);
6486 verifyFormat(
6487 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6488 " aaaaaaaaaaaaa);",
6489 Style);
6490 verifyFormat(
6491 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6492 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6493 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6494 " aaaaaaaaaaaaa);",
6495 Style);
6496 verifyFormat(
6497 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6498 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6499 " aaaaaaaaaaaaa);",
6500 Style);
6501 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6504 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6506 Style);
6507 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6508 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6511 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6513 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6514 Style);
6515 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6517 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6518 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6519 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6520 Style);
6521 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6522 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6523 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6524 Style);
6525 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6527 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6528 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6529 Style);
6530 verifyFormat(
6531 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6532 " aaaaaaaaaaaaaaa :\n"
6533 " aaaaaaaaaaaaaaa;",
6534 Style);
6535 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6536 " aaaaaaaaa ?\n"
6537 " b :\n"
6538 " c);",
6539 Style);
6540 verifyFormat("unsigned Indent =\n"
6541 " format(TheLine.First,\n"
6542 " IndentForLevel[TheLine.Level] >= 0 ?\n"
6543 " IndentForLevel[TheLine.Level] :\n"
6544 " TheLine * 2,\n"
6545 " TheLine.InPPDirective, PreviousEndOfLineColumn);",
6546 Style);
6547 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6548 " aaaaaaaaaaaaaaa :\n"
6549 " bbbbbbbbbbbbbbb ? //\n"
6550 " ccccccccccccccc :\n"
6551 " ddddddddddddddd;",
6552 Style);
6553 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6554 " aaaaaaaaaaaaaaa :\n"
6555 " (bbbbbbbbbbbbbbb ? //\n"
6556 " ccccccccccccccc :\n"
6557 " ddddddddddddddd);",
6558 Style);
6559 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6560 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6561 " ccccccccccccccccccccccccccc;",
6562 Style);
6563 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6564 " aaaaa :\n"
6565 " bbbbbbbbbbbbbbb + cccccccccccccccc;",
6566 Style);
6567
6568 // Chained conditionals
6569 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6570 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6571 " 3333333333333333;",
6572 Style);
6573 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6574 " bbbbbbbbbb ? 2222222222222222 :\n"
6575 " 3333333333333333;",
6576 Style);
6577 verifyFormat("return aaaaaaaaaa ? 1111111111111111 :\n"
6578 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6579 " 3333333333333333;",
6580 Style);
6581 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6582 " bbbbbbbbbbbbbbbb ? 222222 :\n"
6583 " 333333;",
6584 Style);
6585 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6586 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6587 " cccccccccccccccc ? 3333333333333333 :\n"
6588 " 4444444444444444;",
6589 Style);
6590 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6591 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6592 " 3333333333333333;",
6593 Style);
6594 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6595 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6596 " (aaa ? bbb : ccc);",
6597 Style);
6598 verifyFormat(
6599 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6600 " cccccccccccccccccc) :\n"
6601 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6602 " 3333333333333333;",
6603 Style);
6604 verifyFormat(
6605 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6606 " cccccccccccccccccc) :\n"
6607 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6608 " 3333333333333333;",
6609 Style);
6610 verifyFormat(
6611 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6612 " dddddddddddddddddd) :\n"
6613 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6614 " 3333333333333333;",
6615 Style);
6616 verifyFormat(
6617 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6618 " dddddddddddddddddd) :\n"
6619 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6620 " 3333333333333333;",
6621 Style);
6622 verifyFormat(
6623 "return aaaaaaaaa ? 1111111111111111 :\n"
6624 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6625 " a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6626 " dddddddddddddddddd)\n",
6627 Style);
6628 verifyFormat(
6629 "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6630 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6631 " (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6632 " cccccccccccccccccc);",
6633 Style);
6634 verifyFormat(
6635 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6636 " ccccccccccccccccc ? dddddddddddddddddd :\n"
6637 " eeeeeeeeeeeeeeeeee) :\n"
6638 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6639 " 3333333333333333;",
6640 Style);
6641 verifyFormat(
6642 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6643 " ccccccccccccc ? dddddddddddddddddd :\n"
6644 " eeeeeeeeeeeeeeeeee) :\n"
6645 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6646 " 3333333333333333;",
6647 Style);
6648 verifyFormat(
6649 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6650 " ccccccccccccccccc ? dddddddddddddddddd :\n"
6651 " eeeeeeeeeeeeeeeeee) :\n"
6652 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6653 " 3333333333333333;",
6654 Style);
6655 verifyFormat(
6656 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6657 " cccccccccccccccccc :\n"
6658 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6659 " 3333333333333333;",
6660 Style);
6661 verifyFormat(
6662 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6663 " cccccccccccccccccc ? dddddddddddddddddd :\n"
6664 " eeeeeeeeeeeeeeeeee :\n"
6665 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6666 " 3333333333333333;",
6667 Style);
6668 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6669 " (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6670 " cccccccccccccccccc ? dddddddddddddddddd :\n"
6671 " eeeeeeeeeeeeeeeeee) :\n"
6672 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6673 " 3333333333333333;",
6674 Style);
6675 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6676 " aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6677 " cccccccccccccccccccc ? dddddddddddddddddd :\n"
6678 " eeeeeeeeeeeeeeeeee :\n"
6679 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6680 " 3333333333333333;",
6681 Style);
6682}
6683
6684TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6685 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6686 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6687 verifyFormat("bool a = true, b = false;");
6688
6689 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6690 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6691 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6692 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6693 verifyFormat(
6694 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6695 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6696 " d = e && f;");
6697 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6698 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6699 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6700 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6701 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6702 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6703
6704 FormatStyle Style = getGoogleStyle();
6705 Style.PointerAlignment = FormatStyle::PAS_Left;
6706 Style.DerivePointerAlignment = false;
6707 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6708 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6709 " *b = bbbbbbbbbbbbbbbbbbb;",
6710 Style);
6711 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6712 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6713 Style);
6714 verifyFormat("vector<int*> a, b;", Style);
6715 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6716}
6717
6718TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6719 verifyFormat("arr[foo ? bar : baz];");
6720 verifyFormat("f()[foo ? bar : baz];");
6721 verifyFormat("(a + b)[foo ? bar : baz];");
6722 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6723}
6724
6725TEST_F(FormatTest, AlignsStringLiterals) {
6726 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6727 " \"short literal\");");
6728 verifyFormat(
6729 "looooooooooooooooooooooooongFunction(\n"
6730 " \"short literal\"\n"
6731 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6732 verifyFormat("someFunction(\"Always break between multi-line\"\n"
6733 " \" string literals\",\n"
6734 " and, other, parameters);");
6735 EXPECT_EQ("fun + \"1243\" /* comment */\n"
6736 " \"5678\";",
6737 format("fun + \"1243\" /* comment */\n"
6738 " \"5678\";",
6739 getLLVMStyleWithColumns(28)));
6740 EXPECT_EQ(
6741 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6742 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6743 " \"aaaaaaaaaaaaaaaa\";",
6744 format("aaaaaa ="
6745 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6746 "aaaaaaaaaaaaaaaaaaaaa\" "
6747 "\"aaaaaaaaaaaaaaaa\";"));
6748 verifyFormat("a = a + \"a\"\n"
6749 " \"a\"\n"
6750 " \"a\";");
6751 verifyFormat("f(\"a\", \"b\"\n"
6752 " \"c\");");
6753
6754 verifyFormat(
6755 "#define LL_FORMAT \"ll\"\n"
6756 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6757 " \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6758
6759 verifyFormat("#define A(X) \\\n"
6760 " \"aaaaa\" #X \"bbbbbb\" \\\n"
6761 " \"ccccc\"",
6762 getLLVMStyleWithColumns(23));
6763 verifyFormat("#define A \"def\"\n"
6764 "f(\"abc\" A \"ghi\"\n"
6765 " \"jkl\");");
6766
6767 verifyFormat("f(L\"a\"\n"
6768 " L\"b\");");
6769 verifyFormat("#define A(X) \\\n"
6770 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6771 " L\"ccccc\"",
6772 getLLVMStyleWithColumns(25));
6773
6774 verifyFormat("f(@\"a\"\n"
6775 " @\"b\");");
6776 verifyFormat("NSString s = @\"a\"\n"
6777 " @\"b\"\n"
6778 " @\"c\";");
6779 verifyFormat("NSString s = @\"a\"\n"
6780 " \"b\"\n"
6781 " \"c\";");
6782}
6783
6784TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6785 FormatStyle Style = getLLVMStyle();
6786 // No declarations or definitions should be moved to own line.
6787 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6788 verifyFormat("class A {\n"
6789 " int f() { return 1; }\n"
6790 " int g();\n"
6791 "};\n"
6792 "int f() { return 1; }\n"
6793 "int g();\n",
6794 Style);
6795
6796 // All declarations and definitions should have the return type moved to its
6797 // own line.
6798 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6799 Style.TypenameMacros = {"LIST"};
6800 verifyFormat("SomeType\n"
6801 "funcdecl(LIST(uint64_t));",
6802 Style);
6803 verifyFormat("class E {\n"
6804 " int\n"
6805 " f() {\n"
6806 " return 1;\n"
6807 " }\n"
6808 " int\n"
6809 " g();\n"
6810 "};\n"
6811 "int\n"
6812 "f() {\n"
6813 " return 1;\n"
6814 "}\n"
6815 "int\n"
6816 "g();\n",
6817 Style);
6818
6819 // Top-level definitions, and no kinds of declarations should have the
6820 // return type moved to its own line.
6821 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6822 verifyFormat("class B {\n"
6823 " int f() { return 1; }\n"
6824 " int g();\n"
6825 "};\n"
6826 "int\n"
6827 "f() {\n"
6828 " return 1;\n"
6829 "}\n"
6830 "int g();\n",
6831 Style);
6832
6833 // Top-level definitions and declarations should have the return type moved
6834 // to its own line.
6835 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6836 verifyFormat("class C {\n"
6837 " int f() { return 1; }\n"
6838 " int g();\n"
6839 "};\n"
6840 "int\n"
6841 "f() {\n"
6842 " return 1;\n"
6843 "}\n"
6844 "int\n"
6845 "g();\n",
6846 Style);
6847
6848 // All definitions should have the return type moved to its own line, but no
6849 // kinds of declarations.
6850 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6851 verifyFormat("class D {\n"
6852 " int\n"
6853 " f() {\n"
6854 " return 1;\n"
6855 " }\n"
6856 " int g();\n"
6857 "};\n"
6858 "int\n"
6859 "f() {\n"
6860 " return 1;\n"
6861 "}\n"
6862 "int g();\n",
6863 Style);
6864 verifyFormat("const char *\n"
6865 "f(void) {\n" // Break here.
6866 " return \"\";\n"
6867 "}\n"
6868 "const char *bar(void);\n", // No break here.
6869 Style);
6870 verifyFormat("template <class T>\n"
6871 "T *\n"
6872 "f(T &c) {\n" // Break here.
6873 " return NULL;\n"
6874 "}\n"
6875 "template <class T> T *f(T &c);\n", // No break here.
6876 Style);
6877 verifyFormat("class C {\n"
6878 " int\n"
6879 " operator+() {\n"
6880 " return 1;\n"
6881 " }\n"
6882 " int\n"
6883 " operator()() {\n"
6884 " return 1;\n"
6885 " }\n"
6886 "};\n",
6887 Style);
6888 verifyFormat("void\n"
6889 "A::operator()() {}\n"
6890 "void\n"
6891 "A::operator>>() {}\n"
6892 "void\n"
6893 "A::operator+() {}\n"
6894 "void\n"
6895 "A::operator*() {}\n"
6896 "void\n"
6897 "A::operator->() {}\n"
6898 "void\n"
6899 "A::operator void *() {}\n"
6900 "void\n"
6901 "A::operator void &() {}\n"
6902 "void\n"
6903 "A::operator void &&() {}\n"
6904 "void\n"
6905 "A::operator char *() {}\n"
6906 "void\n"
6907 "A::operator[]() {}\n"
6908 "void\n"
6909 "A::operator!() {}\n"
6910 "void\n"
6911 "A::operator**() {}\n"
6912 "void\n"
6913 "A::operator<Foo> *() {}\n"
6914 "void\n"
6915 "A::operator<Foo> **() {}\n"
6916 "void\n"
6917 "A::operator<Foo> &() {}\n"
6918 "void\n"
6919 "A::operator void **() {}\n",
6920 Style);
6921 verifyFormat("constexpr auto\n"
6922 "operator()() const -> reference {}\n"
6923 "constexpr auto\n"
6924 "operator>>() const -> reference {}\n"
6925 "constexpr auto\n"
6926 "operator+() const -> reference {}\n"
6927 "constexpr auto\n"
6928 "operator*() const -> reference {}\n"
6929 "constexpr auto\n"
6930 "operator->() const -> reference {}\n"
6931 "constexpr auto\n"
6932 "operator++() const -> reference {}\n"
6933 "constexpr auto\n"
6934 "operator void *() const -> reference {}\n"
6935 "constexpr auto\n"
6936 "operator void **() const -> reference {}\n"
6937 "constexpr auto\n"
6938 "operator void *() const -> reference {}\n"
6939 "constexpr auto\n"
6940 "operator void &() const -> reference {}\n"
6941 "constexpr auto\n"
6942 "operator void &&() const -> reference {}\n"
6943 "constexpr auto\n"
6944 "operator char *() const -> reference {}\n"
6945 "constexpr auto\n"
6946 "operator!() const -> reference {}\n"
6947 "constexpr auto\n"
6948 "operator[]() const -> reference {}\n",
6949 Style);
6950 verifyFormat("void *operator new(std::size_t s);", // No break here.
6951 Style);
6952 verifyFormat("void *\n"
6953 "operator new(std::size_t s) {}",
6954 Style);
6955 verifyFormat("void *\n"
6956 "operator delete[](void *ptr) {}",
6957 Style);
6958 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6959 verifyFormat("const char *\n"
6960 "f(void)\n" // Break here.
6961 "{\n"
6962 " return \"\";\n"
6963 "}\n"
6964 "const char *bar(void);\n", // No break here.
6965 Style);
6966 verifyFormat("template <class T>\n"
6967 "T *\n" // Problem here: no line break
6968 "f(T &c)\n" // Break here.
6969 "{\n"
6970 " return NULL;\n"
6971 "}\n"
6972 "template <class T> T *f(T &c);\n", // No break here.
6973 Style);
6974 verifyFormat("int\n"
6975 "foo(A<bool> a)\n"
6976 "{\n"
6977 " return a;\n"
6978 "}\n",
6979 Style);
6980 verifyFormat("int\n"
6981 "foo(A<8> a)\n"
6982 "{\n"
6983 " return a;\n"
6984 "}\n",
6985 Style);
6986 verifyFormat("int\n"
6987 "foo(A<B<bool>, 8> a)\n"
6988 "{\n"
6989 " return a;\n"
6990 "}\n",
6991 Style);
6992 verifyFormat("int\n"
6993 "foo(A<B<8>, bool> a)\n"
6994 "{\n"
6995 " return a;\n"
6996 "}\n",
6997 Style);
6998 verifyFormat("int\n"
6999 "foo(A<B<bool>, bool> a)\n"
7000 "{\n"
7001 " return a;\n"
7002 "}\n",
7003 Style);
7004 verifyFormat("int\n"
7005 "foo(A<B<8>, 8> a)\n"
7006 "{\n"
7007 " return a;\n"
7008 "}\n",
7009 Style);
7010
7011 Style = getGNUStyle();
7012
7013 // Test for comments at the end of function declarations.
7014 verifyFormat("void\n"
7015 "foo (int a, /*abc*/ int b) // def\n"
7016 "{\n"
7017 "}\n",
7018 Style);
7019
7020 verifyFormat("void\n"
7021 "foo (int a, /* abc */ int b) /* def */\n"
7022 "{\n"
7023 "}\n",
7024 Style);
7025
7026 // Definitions that should not break after return type
7027 verifyFormat("void foo (int a, int b); // def\n", Style);
7028 verifyFormat("void foo (int a, int b); /* def */\n", Style);
7029 verifyFormat("void foo (int a, int b);\n", Style);
7030}
7031
7032TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
7033 FormatStyle NoBreak = getLLVMStyle();
7034 NoBreak.AlwaysBreakBeforeMultilineStrings = false;
7035 FormatStyle Break = getLLVMStyle();
7036 Break.AlwaysBreakBeforeMultilineStrings = true;
7037 verifyFormat("aaaa = \"bbbb\"\n"
7038 " \"cccc\";",
7039 NoBreak);
7040 verifyFormat("aaaa =\n"
7041 " \"bbbb\"\n"
7042 " \"cccc\";",
7043 Break);
7044 verifyFormat("aaaa(\"bbbb\"\n"
7045 " \"cccc\");",
7046 NoBreak);
7047 verifyFormat("aaaa(\n"
7048 " \"bbbb\"\n"
7049 " \"cccc\");",
7050 Break);
7051 verifyFormat("aaaa(qqq, \"bbbb\"\n"
7052 " \"cccc\");",
7053 NoBreak);
7054 verifyFormat("aaaa(qqq,\n"
7055 " \"bbbb\"\n"
7056 " \"cccc\");",
7057 Break);
7058 verifyFormat("aaaa(qqq,\n"
7059 " L\"bbbb\"\n"
7060 " L\"cccc\");",
7061 Break);
7062 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
7063 " \"bbbb\"));",
7064 Break);
7065 verifyFormat("string s = someFunction(\n"
7066 " \"abc\"\n"
7067 " \"abc\");",
7068 Break);
7069
7070 // As we break before unary operators, breaking right after them is bad.
7071 verifyFormat("string foo = abc ? \"x\"\n"
7072 " \"blah blah blah blah blah blah\"\n"
7073 " : \"y\";",
7074 Break);
7075
7076 // Don't break if there is no column gain.
7077 verifyFormat("f(\"aaaa\"\n"
7078 " \"bbbb\");",
7079 Break);
7080
7081 // Treat literals with escaped newlines like multi-line string literals.
7082 EXPECT_EQ("x = \"a\\\n"
7083 "b\\\n"
7084 "c\";",
7085 format("x = \"a\\\n"
7086 "b\\\n"
7087 "c\";",
7088 NoBreak));
7089 EXPECT_EQ("xxxx =\n"
7090 " \"a\\\n"
7091 "b\\\n"
7092 "c\";",
7093 format("xxxx = \"a\\\n"
7094 "b\\\n"
7095 "c\";",
7096 Break));
7097
7098 EXPECT_EQ("NSString *const kString =\n"
7099 " @\"aaaa\"\n"
7100 " @\"bbbb\";",
7101 format("NSString *const kString = @\"aaaa\"\n"
7102 "@\"bbbb\";",
7103 Break));
7104
7105 Break.ColumnLimit = 0;
7106 verifyFormat("const char *hello = \"hello llvm\";", Break);
7107}
7108
7109TEST_F(FormatTest, AlignsPipes) {
7110 verifyFormat(
7111 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7112 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7113 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7114 verifyFormat(
7115 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7116 " << aaaaaaaaaaaaaaaaaaaa;");
7117 verifyFormat(
7118 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7119 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7120 verifyFormat(
7121 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7122 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7123 verifyFormat(
7124 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7125 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7126 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7127 verifyFormat(
7128 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7129 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7130 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7131 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7132 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7133 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7134 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7135 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7136 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7137 verifyFormat(
7138 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7139 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7140 verifyFormat(
7141 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7142 " aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7143
7144 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7145 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7146 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7147 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7148 " aaaaaaaaaaaaaaaaaaaaa)\n"
7149 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7150 verifyFormat("LOG_IF(aaa == //\n"
7151 " bbb)\n"
7152 " << a << b;");
7153
7154 // But sometimes, breaking before the first "<<" is desirable.
7155 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7156 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7157 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7158 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7159 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7160 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7161 " << BEF << IsTemplate << Description << E->getType();");
7162 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7163 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7165 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7166 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7167 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7168 " << aaa;");
7169
7170 verifyFormat(
7171 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7172 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7173
7174 // Incomplete string literal.
7175 EXPECT_EQ("llvm::errs() << \"\n"
7176 " << a;",
7177 format("llvm::errs() << \"\n<<a;"));
7178
7179 verifyFormat("void f() {\n"
7180 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7181 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7182 "}");
7183
7184 // Handle 'endl'.
7185 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7186 " << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7187 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7188
7189 // Handle '\n'.
7190 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7191 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7192 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7193 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7194 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7195 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7196 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7197}
7198
7199TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7200 verifyFormat("return out << \"somepacket = {\\n\"\n"
7201 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7202 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7203 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7204 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7205 " << \"}\";");
7206
7207 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7208 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7209 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7210 verifyFormat(
7211 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7212 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7213 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7214 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7215 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7216 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7217 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7218 verifyFormat(
7219 "void f() {\n"
7220 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7221 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7222 "}");
7223
7224 // Breaking before the first "<<" is generally not desirable.
7225 verifyFormat(
7226 "llvm::errs()\n"
7227 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7228 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7229 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7230 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7231 getLLVMStyleWithColumns(70));
7232 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7233 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7234 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7235 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7236 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7237 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7238 getLLVMStyleWithColumns(70));
7239
7240 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7241 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7242 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7243 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7244 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7245 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7246 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7247 " (aaaa + aaaa);",
7248 getLLVMStyleWithColumns(40));
7249 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7250 " (aaaaaaa + aaaaa));",
7251 getLLVMStyleWithColumns(40));
7252 verifyFormat(
7253 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7254 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7255 " bbbbbbbbbbbbbbbbbbbbbbb);");
7256}
7257
7258TEST_F(FormatTest, UnderstandsEquals) {
7259 verifyFormat(
7260 "aaaaaaaaaaaaaaaaa =\n"
7261 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7262 verifyFormat(
7263 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7264 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7265 verifyFormat(
7266 "if (a) {\n"
7267 " f();\n"
7268 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7269 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7270 "}");
7271
7272 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7273 " 100000000 + 10000000) {\n}");
7274}
7275
7276TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7277 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7278 " .looooooooooooooooooooooooooooooooooooooongFunction();");
7279
7280 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7281 " ->looooooooooooooooooooooooooooooooooooooongFunction();");
7282
7283 verifyFormat(
7284 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7285 " Parameter2);");
7286
7287 verifyFormat(
7288 "ShortObject->shortFunction(\n"
7289 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7290 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7291
7292 verifyFormat("loooooooooooooongFunction(\n"
7293 " LoooooooooooooongObject->looooooooooooooooongFunction());");
7294
7295 verifyFormat(
7296 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7297 " ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7298
7299 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7300 " .WillRepeatedly(Return(SomeValue));");
7301 verifyFormat("void f() {\n"
7302 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7303 " .Times(2)\n"
7304 " .WillRepeatedly(Return(SomeValue));\n"
7305 "}");
7306 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7307 " ccccccccccccccccccccccc);");
7308 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7309 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7310 " .aaaaa(aaaaa),\n"
7311 " aaaaaaaaaaaaaaaaaaaaa);");
7312 verifyFormat("void f() {\n"
7313 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7314 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7315 "}");
7316 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7317 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7318 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7319 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7320 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7321 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7322 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7323 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7324 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7325 "}");
7326
7327 // Here, it is not necessary to wrap at "." or "->".
7328 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7329 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7330 verifyFormat(
7331 "aaaaaaaaaaa->aaaaaaaaa(\n"
7332 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7333 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7334
7335 verifyFormat(
7336 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7337 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7338 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7339 " aaaaaaaaa()->aaaaaa()->aaaaa());");
7340 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7341 " aaaaaaaaa()->aaaaaa()->aaaaa());");
7342
7343 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7344 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7345 " .a();");
7346
7347 FormatStyle NoBinPacking = getLLVMStyle();
7348 NoBinPacking.BinPackParameters = false;
7349 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7350 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7351 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7352 " aaaaaaaaaaaaaaaaaaa,\n"
7353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7354 NoBinPacking);
7355
7356 // If there is a subsequent call, change to hanging indentation.
7357 verifyFormat(
7358 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7359 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7360 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7361 verifyFormat(
7362 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7363 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7364 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7366 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7367 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7370}
7371
7372TEST_F(FormatTest, WrapsTemplateDeclarations) {
7373 verifyFormat("template <typename T>\n"
7374 "virtual void loooooooooooongFunction(int Param1, int Param2);");
7375 verifyFormat("template <typename T>\n"
7376 "// T should be one of {A, B}.\n"
7377 "virtual void loooooooooooongFunction(int Param1, int Param2);");
7378 verifyFormat(
7379 "template <typename T>\n"
7380 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7381 verifyFormat("template <typename T>\n"
7382 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7383 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7384 verifyFormat(
7385 "template <typename T>\n"
7386 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7387 " int Paaaaaaaaaaaaaaaaaaaaram2);");
7388 verifyFormat(
7389 "template <typename T>\n"
7390 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7391 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7392 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7393 verifyFormat("template <typename T>\n"
7394 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7395 " int aaaaaaaaaaaaaaaaaaaaaa);");
7396 verifyFormat(
7397 "template <typename T1, typename T2 = char, typename T3 = char,\n"
7398 " typename T4 = char>\n"
7399 "void f();");
7400 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7401 " template <typename> class cccccccccccccccccccccc,\n"
7402 " typename ddddddddddddd>\n"
7403 "class C {};");
7404 verifyFormat(
7405 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7407
7408 verifyFormat("void f() {\n"
7409 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7410 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7411 "}");
7412
7413 verifyFormat("template <typename T> class C {};");
7414 verifyFormat("template <typename T> void f();");
7415 verifyFormat("template <typename T> void f() {}");
7416 verifyFormat(
7417 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7419 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7420 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7421 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7422 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7423 " bbbbbbbbbbbbbbbbbbbbbbbb);",
7424 getLLVMStyleWithColumns(72));
7425 EXPECT_EQ("static_cast<A< //\n"
7426 " B> *>(\n"
7427 "\n"
7428 ");",
7429 format("static_cast<A<//\n"
7430 " B>*>(\n"
7431 "\n"
7432 " );"));
7433 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7434 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7435
7436 FormatStyle AlwaysBreak = getLLVMStyle();
7437 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7438 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7439 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7440 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7441 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7442 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7443 " ccccccccccccccccccccccccccccccccccccccccccccccc);");
7444 verifyFormat("template <template <typename> class Fooooooo,\n"
7445 " template <typename> class Baaaaaaar>\n"
7446 "struct C {};",
7447 AlwaysBreak);
7448 verifyFormat("template <typename T> // T can be A, B or C.\n"
7449 "struct C {};",
7450 AlwaysBreak);
7451 verifyFormat("template <enum E> class A {\n"
7452 "public:\n"
7453 " E *f();\n"
7454 "};");
7455
7456 FormatStyle NeverBreak = getLLVMStyle();
7457 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7458 verifyFormat("template <typename T> class C {};", NeverBreak);
7459 verifyFormat("template <typename T> void f();", NeverBreak);
7460 verifyFormat("template <typename T> void f() {}", NeverBreak);
7461 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7462 "bbbbbbbbbbbbbbbbbbbb) {}",
7463 NeverBreak);
7464 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7465 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7466 " ccccccccccccccccccccccccccccccccccccccccccccccc);",
7467 NeverBreak);
7468 verifyFormat("template <template <typename> class Fooooooo,\n"
7469 " template <typename> class Baaaaaaar>\n"
7470 "struct C {};",
7471 NeverBreak);
7472 verifyFormat("template <typename T> // T can be A, B or C.\n"
7473 "struct C {};",
7474 NeverBreak);
7475 verifyFormat("template <enum E> class A {\n"
7476 "public:\n"
7477 " E *f();\n"
7478 "};",
7479 NeverBreak);
7480 NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7481 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7482 "bbbbbbbbbbbbbbbbbbbb) {}",
7483 NeverBreak);
7484}
7485
7486TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7487 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7488 Style.ColumnLimit = 60;
7489 EXPECT_EQ("// Baseline - no comments.\n"
7490 "template <\n"
7491 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7492 "void f() {}",
7493 format("// Baseline - no comments.\n"
7494 "template <\n"
7495 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7496 "void f() {}",
7497 Style));
7498
7499 EXPECT_EQ("template <\n"
7500 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7501 "void f() {}",
7502 format("template <\n"
7503 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7504 "void f() {}",
7505 Style));
7506
7507 EXPECT_EQ(
7508 "template <\n"
7509 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7510 "void f() {}",
7511 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7512 "void f() {}",
7513 Style));
7514
7515 EXPECT_EQ(
7516 "template <\n"
7517 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7518 " // multiline\n"
7519 "void f() {}",
7520 format("template <\n"
7521 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7522 " // multiline\n"
7523 "void f() {}",
7524 Style));
7525
7526 EXPECT_EQ(
7527 "template <typename aaaaaaaaaa<\n"
7528 " bbbbbbbbbbbb>::value> // trailing loooong\n"
7529 "void f() {}",
7530 format(
7531 "template <\n"
7532 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7533 "void f() {}",
7534 Style));
7535}
7536
7537TEST_F(FormatTest, WrapsTemplateParameters) {
7538 FormatStyle Style = getLLVMStyle();
7539 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7540 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7541 verifyFormat(
7542 "template <typename... a> struct q {};\n"
7543 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7544 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7545 " y;",
7546 Style);
7547 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7548 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7549 verifyFormat(
7550 "template <typename... a> struct r {};\n"
7551 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7552 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7553 " y;",
7554 Style);
7555 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7556 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7557 verifyFormat("template <typename... a> struct s {};\n"
7558 "extern s<\n"
7559 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7560 "aaaaaaaaaaaaaaaaaaaaaa,\n"
7561 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7562 "aaaaaaaaaaaaaaaaaaaaaa>\n"
7563 " y;",
7564 Style);
7565 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7566 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7567 verifyFormat("template <typename... a> struct t {};\n"
7568 "extern t<\n"
7569 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7570 "aaaaaaaaaaaaaaaaaaaaaa,\n"
7571 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7572 "aaaaaaaaaaaaaaaaaaaaaa>\n"
7573 " y;",
7574 Style);
7575}
7576
7577TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7578 verifyFormat(
7579 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7581 verifyFormat(
7582 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7585
7586 // FIXME: Should we have the extra indent after the second break?
7587 verifyFormat(
7588 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7590 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7591
7592 verifyFormat(
7593 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7594 " cccccccccccccccccccccccccccccccccccccccccccccc());");
7595
7596 // Breaking at nested name specifiers is generally not desirable.
7597 verifyFormat(
7598 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7599 " aaaaaaaaaaaaaaaaaaaaaaa);");
7600
7601 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7603 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7604 " aaaaaaaaaaaaaaaaaaaaa);",
7605 getLLVMStyleWithColumns(74));
7606
7607 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7608 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7609 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7610}
7611
7612TEST_F(FormatTest, UnderstandsTemplateParameters) {
7613 verifyFormat("A<int> a;");
7614 verifyFormat("A<A<A<int>>> a;");
7615 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7616 verifyFormat("bool x = a < 1 || 2 > a;");
7617 verifyFormat("bool x = 5 < f<int>();");
7618 verifyFormat("bool x = f<int>() > 5;");
7619 verifyFormat("bool x = 5 < a<int>::x;");
7620 verifyFormat("bool x = a < 4 ? a > 2 : false;");
7621 verifyFormat("bool x = f() ? a < 2 : a > 2;");
7622
7623 verifyGoogleFormat("A<A<int>> a;");
7624 verifyGoogleFormat("A<A<A<int>>> a;");
7625 verifyGoogleFormat("A<A<A<A<int>>>> a;");
7626 verifyGoogleFormat("A<A<int> > a;");
7627 verifyGoogleFormat("A<A<A<int> > > a;");
7628 verifyGoogleFormat("A<A<A<A<int> > > > a;");
7629 verifyGoogleFormat("A<::A<int>> a;");
7630 verifyGoogleFormat("A<::A> a;");
7631 verifyGoogleFormat("A< ::A> a;");
7632 verifyGoogleFormat("A< ::A<int> > a;");
7633 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7634 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7635 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7636 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7637 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7638 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7639
7640 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7641
7642 // template closer followed by a token that starts with > or =
7643 verifyFormat("bool b = a<1> > 1;");
7644 verifyFormat("bool b = a<1> >= 1;");
7645 verifyFormat("int i = a<1> >> 1;");
7646 FormatStyle Style = getLLVMStyle();
7647 Style.SpaceBeforeAssignmentOperators = false;
7648 verifyFormat("bool b= a<1> == 1;", Style);
7649 verifyFormat("a<int> = 1;", Style);
7650 verifyFormat("a<int> >>= 1;", Style);
7651
7652 verifyFormat("test >> a >> b;");
7653 verifyFormat("test << a >> b;");
7654
7655 verifyFormat("f<int>();");
7656 verifyFormat("template <typename T> void f() {}");
7657 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7658 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7659 "sizeof(char)>::type>;");
7660 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7661 verifyFormat("f(a.operator()<A>());");
7662 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7663 " .template operator()<A>());",
7664 getLLVMStyleWithColumns(35));
7665
7666 // Not template parameters.
7667 verifyFormat("return a < b && c > d;");
7668 verifyFormat("void f() {\n"
7669 " while (a < b && c > d) {\n"
7670 " }\n"
7671 "}");
7672 verifyFormat("template <typename... Types>\n"
7673 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7674
7675 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7677 getLLVMStyleWithColumns(60));
7678 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7679 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7680 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7681 verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7682}
7683
7684TEST_F(FormatTest, UnderstandsShiftOperators) {
7685 verifyFormat("if (i < x >> 1)");
7686 verifyFormat("while (i < x >> 1)");
7687 verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7688 verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7689 verifyFormat(
7690 "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7691 verifyFormat("Foo.call<Bar<Function>>()");
7692 verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7693 verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7694 "++i, v = v >> 1)");
7695 verifyFormat("if (w<u<v<x>>, 1>::t)");
7696}
7697
7698TEST_F(FormatTest, BitshiftOperatorWidth) {
7699 EXPECT_EQ("int a = 1 << 2; /* foo\n"
7700 " bar */",
7701 format("int a=1<<2; /* foo\n"
7702 " bar */"));
7703
7704 EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7705 " bar */",
7706 format("int b =256>>1 ; /* foo\n"
7707 " bar */"));
7708}
7709
7710TEST_F(FormatTest, UnderstandsBinaryOperators) {
7711 verifyFormat("COMPARE(a, ==, b);");
7712 verifyFormat("auto s = sizeof...(Ts) - 1;");
7713}
7714
7715TEST_F(FormatTest, UnderstandsPointersToMembers) {
7716 verifyFormat("int A::*x;");
7717 verifyFormat("int (S::*func)(void *);");
7718 verifyFormat("void f() { int (S::*func)(void *); }");
7719 verifyFormat("typedef bool *(Class::*Member)() const;");
7720 verifyFormat("void f() {\n"
7721 " (a->*f)();\n"
7722 " a->*x;\n"
7723 " (a.*f)();\n"
7724 " ((*a).*f)();\n"
7725 " a.*x;\n"
7726 "}");
7727 verifyFormat("void f() {\n"
7728 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7729 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7730 "}");
7731 verifyFormat(
7732 "(aaaaaaaaaa->*bbbbbbb)(\n"
7733 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7734 FormatStyle Style = getLLVMStyle();
7735 Style.PointerAlignment = FormatStyle::PAS_Left;
7736 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7737}
7738
7739TEST_F(FormatTest, UnderstandsUnaryOperators) {
7740 verifyFormat("int a = -2;");
7741 verifyFormat("f(-1, -2, -3);");
7742 verifyFormat("a[-1] = 5;");
7743 verifyFormat("int a = 5 + -2;");
7744 verifyFormat("if (i == -1) {\n}");
7745 verifyFormat("if (i != -1) {\n}");
7746 verifyFormat("if (i > -1) {\n}");
7747 verifyFormat("if (i < -1) {\n}");
7748 verifyFormat("++(a->f());");
7749 verifyFormat("--(a->f());");
7750 verifyFormat("(a->f())++;");
7751 verifyFormat("a[42]++;");
7752 verifyFormat("if (!(a->f())) {\n}");
7753 verifyFormat("if (!+i) {\n}");
7754 verifyFormat("~&a;");
7755
7756 verifyFormat("a-- > b;");
7757 verifyFormat("b ? -a : c;");
7758 verifyFormat("n * sizeof char16;");
7759 verifyFormat("n * alignof char16;", getGoogleStyle());
7760 verifyFormat("sizeof(char);");
7761 verifyFormat("alignof(char);", getGoogleStyle());
7762
7763 verifyFormat("return -1;");
7764 verifyFormat("throw -1;");
7765 verifyFormat("switch (a) {\n"
7766 "case -1:\n"
7767 " break;\n"
7768 "}");
7769 verifyFormat("#define X -1");
7770 verifyFormat("#define X -kConstant");
7771
7772 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7773 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7774
7775 verifyFormat("int a = /* confusing comment */ -1;");
7776 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7777 verifyFormat("int a = i /* confusing comment */++;");
7778
7779 verifyFormat("co_yield -1;");
7780 verifyFormat("co_return -1;");
7781
7782 // Check that * is not treated as a binary operator when we set
7783 // PointerAlignment as PAS_Left after a keyword and not a declaration.
7784 FormatStyle PASLeftStyle = getLLVMStyle();
7785 PASLeftStyle.PointerAlignment = FormatStyle::PAS_Left;
7786 verifyFormat("co_return *a;", PASLeftStyle);
7787 verifyFormat("co_await *a;", PASLeftStyle);
7788 verifyFormat("co_yield *a", PASLeftStyle);
7789 verifyFormat("return *a;", PASLeftStyle);
7790}
7791
7792TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7793 verifyFormat("if (!aaaaaaaaaa( // break\n"
7794 " aaaaa)) {\n"
7795 "}");
7796 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7797 " aaaaa));");
7798 verifyFormat("*aaa = aaaaaaa( // break\n"
7799 " bbbbbb);");
7800}
7801
7802TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7803 verifyFormat("bool operator<();");
7804 verifyFormat("bool operator>();");
7805 verifyFormat("bool operator=();");
7806 verifyFormat("bool operator==();");
7807 verifyFormat("bool operator!=();");
7808 verifyFormat("int operator+();");
7809 verifyFormat("int operator++();");
7810 verifyFormat("int operator++(int) volatile noexcept;");
7811 verifyFormat("bool operator,();");
7812 verifyFormat("bool operator();");
7813 verifyFormat("bool operator()();");
7814 verifyFormat("bool operator[]();");
7815 verifyFormat("operator bool();");
7816 verifyFormat("operator int();");
7817 verifyFormat("operator void *();");
7818 verifyFormat("operator SomeType<int>();");
7819 verifyFormat("operator SomeType<int, int>();");
7820 verifyFormat("operator SomeType<SomeType<int>>();");
7821 verifyFormat("void *operator new(std::size_t size);");
7822 verifyFormat("void *operator new[](std::size_t size);");
7823 verifyFormat("void operator delete(void *ptr);");
7824 verifyFormat("void operator delete[](void *ptr);");
7825 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7826 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7827 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7828 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7829
7830 verifyFormat(
7831 "ostream &operator<<(ostream &OutputStream,\n"
7832 " SomeReallyLongType WithSomeReallyLongValue);");
7833 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7834 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7835 " return left.group < right.group;\n"
7836 "}");
7837 verifyFormat("SomeType &operator=(const SomeType &S);");
7838 verifyFormat("f.template operator()<int>();");
7839
7840 verifyGoogleFormat("operator void*();");
7841 verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7842 verifyGoogleFormat("operator ::A();");
7843
7844 verifyFormat("using A::operator+;");
7845 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7846 "int i;");
7847}
7848
7849TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7850 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7851 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7852 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7853 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7854 verifyFormat("Deleted &operator=(const Deleted &) &;");
7855 verifyFormat("Deleted &operator=(const Deleted &) &&;");
7856 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7857 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7858 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7859 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7860 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7861 verifyFormat("void Fn(T const &) const &;");
7862 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7863 verifyFormat("template <typename T>\n"
7864 "void F(T) && = delete;",
7865 getGoogleStyle());
7866
7867 FormatStyle AlignLeft = getLLVMStyle();
7868 AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7869 verifyFormat("void A::b() && {}", AlignLeft);
7870 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7871 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7872 AlignLeft);
7873 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7874 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7875 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7876 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7877 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7878 verifyFormat("auto Function(T) & -> void;", AlignLeft);
7879 verifyFormat("void Fn(T const&) const&;", AlignLeft);
7880 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7881
7882 FormatStyle Spaces = getLLVMStyle();
7883 Spaces.SpacesInCStyleCastParentheses = true;
7884 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7885 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7886 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7887 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7888
7889 Spaces.SpacesInCStyleCastParentheses = false;
7890 Spaces.SpacesInParentheses = true;
7891 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7892 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7893 Spaces);
7894 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7895 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7896
7897 FormatStyle BreakTemplate = getLLVMStyle();
7898 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7899
7900 verifyFormat("struct f {\n"
7901 " template <class T>\n"
7902 " int &foo(const std::string &str) &noexcept {}\n"
7903 "};",
7904 BreakTemplate);
7905
7906 verifyFormat("struct f {\n"
7907 " template <class T>\n"
7908 " int &foo(const std::string &str) &&noexcept {}\n"
7909 "};",
7910 BreakTemplate);
7911
7912 verifyFormat("struct f {\n"
7913 " template <class T>\n"
7914 " int &foo(const std::string &str) const &noexcept {}\n"
7915 "};",
7916 BreakTemplate);
7917
7918 verifyFormat("struct f {\n"
7919 " template <class T>\n"
7920 " int &foo(const std::string &str) const &noexcept {}\n"
7921 "};",
7922 BreakTemplate);
7923
7924 verifyFormat("struct f {\n"
7925 " template <class T>\n"
7926 " auto foo(const std::string &str) &&noexcept -> int & {}\n"
7927 "};",
7928 BreakTemplate);
7929
7930 FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7931 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7932 FormatStyle::BTDS_Yes;
7933 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7934
7935 verifyFormat("struct f {\n"
7936 " template <class T>\n"
7937 " int& foo(const std::string& str) & noexcept {}\n"
7938 "};",
7939 AlignLeftBreakTemplate);
7940
7941 verifyFormat("struct f {\n"
7942 " template <class T>\n"
7943 " int& foo(const std::string& str) && noexcept {}\n"
7944 "};",
7945 AlignLeftBreakTemplate);
7946
7947 verifyFormat("struct f {\n"
7948 " template <class T>\n"
7949 " int& foo(const std::string& str) const& noexcept {}\n"
7950 "};",
7951 AlignLeftBreakTemplate);
7952
7953 verifyFormat("struct f {\n"
7954 " template <class T>\n"
7955 " int& foo(const std::string& str) const&& noexcept {}\n"
7956 "};",
7957 AlignLeftBreakTemplate);
7958
7959 verifyFormat("struct f {\n"
7960 " template <class T>\n"
7961 " auto foo(const std::string& str) && noexcept -> int& {}\n"
7962 "};",
7963 AlignLeftBreakTemplate);
7964
7965 // The `&` in `Type&` should not be confused with a trailing `&` of
7966 // DEPRECATED(reason) member function.
7967 verifyFormat("struct f {\n"
7968 " template <class T>\n"
7969 " DEPRECATED(reason)\n"
7970 " Type &foo(arguments) {}\n"
7971 "};",
7972 BreakTemplate);
7973
7974 verifyFormat("struct f {\n"
7975 " template <class T>\n"
7976 " DEPRECATED(reason)\n"
7977 " Type& foo(arguments) {}\n"
7978 "};",
7979 AlignLeftBreakTemplate);
7980
7981 verifyFormat("void (*foopt)(int) = &func;");
7982}
7983
7984TEST_F(FormatTest, UnderstandsNewAndDelete) {
7985 verifyFormat("void f() {\n"
7986 " A *a = new A;\n"
7987 " A *a = new (placement) A;\n"
7988 " delete a;\n"
7989 " delete (A *)a;\n"
7990 "}");
7991 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7992 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7993 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7994 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7995 " typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7996 verifyFormat("delete[] h->p;");
7997}
7998
7999TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
8000 verifyFormat("int *f(int *a) {}");
8001 verifyFormat("int main(int argc, char **argv) {}");
8002 verifyFormat("Test::Test(int b) : a(b * b) {}");
8003 verifyIndependentOfContext("f(a, *a);");
8004 verifyFormat("void g() { f(*a); }");
8005 verifyIndependentOfContext("int a = b * 10;");
8006 verifyIndependentOfContext("int a = 10 * b;");
8007 verifyIndependentOfContext("int a = b * c;");
8008 verifyIndependentOfContext("int a += b * c;");
8009 verifyIndependentOfContext("int a -= b * c;");
8010 verifyIndependentOfContext("int a *= b * c;");
8011 verifyIndependentOfContext("int a /= b * c;");
8012 verifyIndependentOfContext("int a = *b;");
8013 verifyIndependentOfContext("int a = *b * c;");
8014 verifyIndependentOfContext("int a = b * *c;");
8015 verifyIndependentOfContext("int a = b * (10);");
8016 verifyIndependentOfContext("S << b * (10);");
8017 verifyIndependentOfContext("return 10 * b;");
8018 verifyIndependentOfContext("return *b * *c;");
8019 verifyIndependentOfContext("return a & ~b;");
8020 verifyIndependentOfContext("f(b ? *c : *d);");
8021 verifyIndependentOfContext("int a = b ? *c : *d;");
8022 verifyIndependentOfContext("*b = a;");
8023 verifyIndependentOfContext("a * ~b;");
8024 verifyIndependentOfContext("a * !b;");
8025 verifyIndependentOfContext("a * +b;");
8026 verifyIndependentOfContext("a * -b;");
8027 verifyIndependentOfContext("a * ++b;");
8028 verifyIndependentOfContext("a * --b;");
8029 verifyIndependentOfContext("a[4] * b;");
8030 verifyIndependentOfContext("a[a * a] = 1;");
8031 verifyIndependentOfContext("f() * b;");
8032 verifyIndependentOfContext("a * [self dostuff];");
8033 verifyIndependentOfContext("int x = a * (a + b);");
8034 verifyIndependentOfContext("(a *)(a + b);");
8035 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
8036 verifyIndependentOfContext("int *pa = (int *)&a;");
8037 verifyIndependentOfContext("return sizeof(int **);");
8038 verifyIndependentOfContext("return sizeof(int ******);");
8039 verifyIndependentOfContext("return (int **&)a;");
8040 verifyIndependentOfContext("f((*PointerToArray)[10]);");
8041 verifyFormat("void f(Type (*parameter)[10]) {}");
8042 verifyFormat("void f(Type (&parameter)[10]) {}");
8043 verifyGoogleFormat("return sizeof(int**);");
8044 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
8045 verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
8046 verifyFormat("auto a = [](int **&, int ***) {};");
8047 verifyFormat("auto PointerBinding = [](const char *S) {};");
8048 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
8049 verifyFormat("[](const decltype(*a) &value) {}");
8050 verifyFormat("[](const typeof(*a) &value) {}");
8051 verifyFormat("[](const _Atomic(a *) &value) {}");
8052 verifyFormat("[](const __underlying_type(a) &value) {}");
8053 verifyFormat("decltype(a * b) F();");
8054 verifyFormat("typeof(a * b) F();");
8055 verifyFormat("#define MACRO() [](A *a) { return 1; }");
8056 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
8057 verifyIndependentOfContext("typedef void (*f)(int *a);");
8058 verifyIndependentOfContext("int i{a * b};");
8059 verifyIndependentOfContext("aaa && aaa->f();");
8060 verifyIndependentOfContext("int x = ~*p;");
8061 verifyFormat("Constructor() : a(a), area(width * height) {}");
8062 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
8063 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
8064 verifyFormat("void f() { f(a, c * d); }");
8065 verifyFormat("void f() { f(new a(), c * d); }");
8066 verifyFormat("void f(const MyOverride &override);");
8067 verifyFormat("void f(const MyFinal &final);");
8068 verifyIndependentOfContext("bool a = f() && override.f();");
8069 verifyIndependentOfContext("bool a = f() && final.f();");
8070
8071 verifyIndependentOfContext("InvalidRegions[*R] = 0;");
8072
8073 verifyIndependentOfContext("A<int *> a;");
8074 verifyIndependentOfContext("A<int **> a;");
8075 verifyIndependentOfContext("A<int *, int *> a;");
8076 verifyIndependentOfContext("A<int *[]> a;");
8077 verifyIndependentOfContext(
8078 "const char *const p = reinterpret_cast<const char *const>(q);");
8079 verifyIndependentOfContext("A<int **, int **> a;");
8080 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
8081 verifyFormat("for (char **a = b; *a; ++a) {\n}");
8082 verifyFormat("for (; a && b;) {\n}");
8083 verifyFormat("bool foo = true && [] { return false; }();");
8084
8085 verifyFormat(
8086 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8088
8089 verifyGoogleFormat("int const* a = &b;");
8090 verifyGoogleFormat("**outparam = 1;");
8091 verifyGoogleFormat("*outparam = a * b;");
8092 verifyGoogleFormat("int main(int argc, char** argv) {}");
8093 verifyGoogleFormat("A<int*> a;");
8094 verifyGoogleFormat("A<int**> a;");
8095 verifyGoogleFormat("A<int*, int*> a;");
8096 verifyGoogleFormat("A<int**, int**> a;");
8097 verifyGoogleFormat("f(b ? *c : *d);");
8098 verifyGoogleFormat("int a = b ? *c : *d;");
8099 verifyGoogleFormat("Type* t = **x;");
8100 verifyGoogleFormat("Type* t = *++*x;");
8101 verifyGoogleFormat("*++*x;");
8102 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
8103 verifyGoogleFormat("Type* t = x++ * y;");
8104 verifyGoogleFormat(
8105 "const char* const p = reinterpret_cast<const char* const>(q);");
8106 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
8107 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
8108 verifyGoogleFormat("template <typename T>\n"
8109 "void f(int i = 0, SomeType** temps = NULL);");
8110
8111 FormatStyle Left = getLLVMStyle();
8112 Left.PointerAlignment = FormatStyle::PAS_Left;
8113 verifyFormat("x = *a(x) = *a(y);", Left);
8114 verifyFormat("for (;; *a = b) {\n}", Left);
8115 verifyFormat("return *this += 1;", Left);
8116 verifyFormat("throw *x;", Left);
8117 verifyFormat("delete *x;", Left);
8118 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
8119 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
8120 verifyFormat("[](const typeof(*a)* ptr) {}", Left);
8121 verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8122 verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8123 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8124 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8125 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8126 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8127
8128 verifyIndependentOfContext("a = *(x + y);");
8129 verifyIndependentOfContext("a = &(x + y);");
8130 verifyIndependentOfContext("*(x + y).call();");
8131 verifyIndependentOfContext("&(x + y)->call();");
8132 verifyFormat("void f() { &(*I).first; }");
8133
8134 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8135 verifyFormat(
8136 "int *MyValues = {\n"
8137 " *A, // Operator detection might be confused by the '{'\n"
8138 " *BB // Operator detection might be confused by previous comment\n"
8139 "};");
8140
8141 verifyIndependentOfContext("if (int *a = &b)");
8142 verifyIndependentOfContext("if (int &a = *b)");
8143 verifyIndependentOfContext("if (a & b[i])");
8144 verifyIndependentOfContext("if constexpr (a & b[i])");
8145 verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8146 verifyIndependentOfContext("if (a * (b * c))");
8147 verifyIndependentOfContext("if constexpr (a * (b * c))");
8148 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8149 verifyIndependentOfContext("if (a::b::c::d & b[i])");
8150 verifyIndependentOfContext("if (*b[i])");
8151 verifyIndependentOfContext("if (int *a = (&b))");
8152 verifyIndependentOfContext("while (int *a = &b)");
8153 verifyIndependentOfContext("while (a * (b * c))");
8154 verifyIndependentOfContext("size = sizeof *a;");
8155 verifyIndependentOfContext("if (a && (b = c))");
8156 verifyFormat("void f() {\n"
8157 " for (const int &v : Values) {\n"
8158 " }\n"
8159 "}");
8160 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8161 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8162 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8163
8164 verifyFormat("#define A (!a * b)");
8165 verifyFormat("#define MACRO \\\n"
8166 " int *i = a * b; \\\n"
8167 " void f(a *b);",
8168 getLLVMStyleWithColumns(19));
8169
8170 verifyIndependentOfContext("A = new SomeType *[Length];");
8171 verifyIndependentOfContext("A = new SomeType *[Length]();");
8172 verifyIndependentOfContext("T **t = new T *;");
8173 verifyIndependentOfContext("T **t = new T *();");
8174 verifyGoogleFormat("A = new SomeType*[Length]();");
8175 verifyGoogleFormat("A = new SomeType*[Length];");
8176 verifyGoogleFormat("T** t = new T*;");
8177 verifyGoogleFormat("T** t = new T*();");
8178
8179 verifyFormat("STATIC_ASSERT((a & b) == 0);");
8180 verifyFormat("STATIC_ASSERT(0 == (a & b));");
8181 verifyFormat("template <bool a, bool b> "
8182 "typename t::if<x && y>::type f() {}");
8183 verifyFormat("template <int *y> f() {}");
8184 verifyFormat("vector<int *> v;");
8185 verifyFormat("vector<int *const> v;");
8186 verifyFormat("vector<int *const **const *> v;");
8187 verifyFormat("vector<int *volatile> v;");
8188 verifyFormat("vector<a *_Nonnull> v;");
8189 verifyFormat("vector<a *_Nullable> v;");
8190 verifyFormat("vector<a *_Null_unspecified> v;");
8191 verifyFormat("vector<a *__ptr32> v;");
8192 verifyFormat("vector<a *__ptr64> v;");
8193 verifyFormat("vector<a *__capability> v;");
8194 FormatStyle TypeMacros = getLLVMStyle();
8195 TypeMacros.TypenameMacros = {"LIST"};
8196 verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8197 verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8198 verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8199 verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8200 verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8201
8202 FormatStyle CustomQualifier = getLLVMStyle();
8203 // Add indentifers that should not be parsed as a qualifier by default.
8204 CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8205 CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8206 CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8207 verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8208 verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8209 verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8210 verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8211 verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8212 verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8213 verifyFormat("vector<a * _NotAQualifier> v;");
8214 verifyFormat("vector<a * __not_a_qualifier> v;");
8215 verifyFormat("vector<a * b> v;");
8216 verifyFormat("foo<b && false>();");
8217 verifyFormat("foo<b & 1>();");
8218 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8219 verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8220 verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8221 verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8222 verifyFormat(
8223 "template <class T, class = typename std::enable_if<\n"
8224 " std::is_integral<T>::value &&\n"
8225 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8226 "void F();",
8227 getLLVMStyleWithColumns(70));
8228 verifyFormat("template <class T,\n"
8229 " class = typename std::enable_if<\n"
8230 " std::is_integral<T>::value &&\n"
8231 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8232 " class U>\n"
8233 "void F();",
8234 getLLVMStyleWithColumns(70));
8235 verifyFormat(
8236 "template <class T,\n"
8237 " class = typename ::std::enable_if<\n"
8238 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8239 "void F();",
8240 getGoogleStyleWithColumns(68));
8241
8242 verifyIndependentOfContext("MACRO(int *i);");
8243 verifyIndependentOfContext("MACRO(auto *a);");
8244 verifyIndependentOfContext("MACRO(const A *a);");
8245 verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8246 verifyIndependentOfContext("MACRO(decltype(A) *a);");
8247 verifyIndependentOfContext("MACRO(typeof(A) *a);");
8248 verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8249 verifyIndependentOfContext("MACRO(A *const a);");
8250 verifyIndependentOfContext("MACRO(A *restrict a);");
8251 verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8252 verifyIndependentOfContext("MACRO(A *__restrict a);");
8253 verifyIndependentOfContext("MACRO(A *volatile a);");
8254 verifyIndependentOfContext("MACRO(A *__volatile a);");
8255 verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8256 verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8257 verifyIndependentOfContext("MACRO(A *_Nullable a);");
8258 verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8259 verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8260 verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8261 verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8262 verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8263 verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8264 verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8265 verifyIndependentOfContext("MACRO(A *__capability);");
8266 verifyIndependentOfContext("MACRO(A &__capability);");
8267 verifyFormat("MACRO(A *__my_qualifier);"); // type declaration
8268 verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8269 // If we add __my_qualifier to AttributeMacros it should always be parsed as
8270 // a type declaration:
8271 verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8272 verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8273 // Also check that TypenameMacros prevents parsing it as multiplication:
8274 verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8275 verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8276
8277 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8278 verifyFormat("void f() { f(float{1}, a * a); }");
8279 // FIXME: Is there a way to make this work?
8280 // verifyIndependentOfContext("MACRO(A *a);");
8281 verifyFormat("MACRO(A &B);");
8282 verifyFormat("MACRO(A *B);");
8283 verifyFormat("void f() { MACRO(A * B); }");
8284 verifyFormat("void f() { MACRO(A & B); }");
8285
8286 // This lambda was mis-formatted after D88956 (treating it as a binop):
8287 verifyFormat("auto x = [](const decltype(x) &ptr) {};");
8288 verifyFormat("auto x = [](const decltype(x) *ptr) {};");
8289 verifyFormat("#define lambda [](const decltype(x) &ptr) {}");
8290 verifyFormat("#define lambda [](const decltype(x) *ptr) {}");
8291
8292 verifyFormat("DatumHandle const *operator->() const { return input_; }");
8293 verifyFormat("return options != nullptr && operator==(*options);");
8294
8295 EXPECT_EQ("#define OP(x) \\\n"
8296 " ostream &operator<<(ostream &s, const A &a) { \\\n"
8297 " return s << a.DebugString(); \\\n"
8298 " }",
8299 format("#define OP(x) \\\n"
8300 " ostream &operator<<(ostream &s, const A &a) { \\\n"
8301 " return s << a.DebugString(); \\\n"
8302 " }",
8303 getLLVMStyleWithColumns(50)));
8304
8305 // FIXME: We cannot handle this case yet; we might be able to figure out that
8306 // foo<x> d > v; doesn't make sense.
8307 verifyFormat("foo<a<b && c> d> v;");
8308
8309 FormatStyle PointerMiddle = getLLVMStyle();
8310 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8311 verifyFormat("delete *x;", PointerMiddle);
8312 verifyFormat("int * x;", PointerMiddle);
8313 verifyFormat("int *[] x;", PointerMiddle);
8314 verifyFormat("template <int * y> f() {}", PointerMiddle);
8315 verifyFormat("int * f(int * a) {}", PointerMiddle);
8316 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8317 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8318 verifyFormat("A<int *> a;", PointerMiddle);
8319 verifyFormat("A<int **> a;", PointerMiddle);
8320 verifyFormat("A<int *, int *> a;", PointerMiddle);
8321 verifyFormat("A<int *[]> a;", PointerMiddle);
8322 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8323 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8324 verifyFormat("T ** t = new T *;", PointerMiddle);
8325
8326 // Member function reference qualifiers aren't binary operators.
8327 verifyFormat("string // break\n"
8328 "operator()() & {}");
8329 verifyFormat("string // break\n"
8330 "operator()() && {}");
8331 verifyGoogleFormat("template <typename T>\n"
8332 "auto x() & -> int {}");
8333}
8334
8335TEST_F(FormatTest, UnderstandsAttributes) {
8336 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8337 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8338 "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8339 FormatStyle AfterType = getLLVMStyle();
8340 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8341 verifyFormat("__attribute__((nodebug)) void\n"
8342 "foo() {}\n",
8343 AfterType);
8344 verifyFormat("__unused void\n"
8345 "foo() {}",
8346 AfterType);
8347
8348 FormatStyle CustomAttrs = getLLVMStyle();
8349 CustomAttrs.AttributeMacros.push_back("__unused");
8350 CustomAttrs.AttributeMacros.push_back("__attr1");
8351 CustomAttrs.AttributeMacros.push_back("__attr2");
8352 CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8353 verifyFormat("vector<SomeType *__attribute((foo))> v;");
8354 verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8355 verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8356 // Check that it is parsed as a multiplication without AttributeMacros and
8357 // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8358 verifyFormat("vector<SomeType * __attr1> v;");
8359 verifyFormat("vector<SomeType __attr1 *> v;");
8360 verifyFormat("vector<SomeType __attr1 *const> v;");
8361 verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8362 verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8363 verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8364 verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8365 verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8366 verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8367 verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8368 verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8369
8370 // Check that these are not parsed as function declarations:
8371 CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8372 CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8373 verifyFormat("SomeType s(InitValue);", CustomAttrs);
8374 verifyFormat("SomeType s{InitValue};", CustomAttrs);
8375 verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8376 verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8377 verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8378 verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8379 verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8380 verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8381}
8382
8383TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8384 // Check that qualifiers on pointers don't break parsing of casts.
8385 verifyFormat("x = (foo *const)*v;");
8386 verifyFormat("x = (foo *volatile)*v;");
8387 verifyFormat("x = (foo *restrict)*v;");
8388 verifyFormat("x = (foo *__attribute__((foo)))*v;");
8389 verifyFormat("x = (foo *_Nonnull)*v;");
8390 verifyFormat("x = (foo *_Nullable)*v;");
8391 verifyFormat("x = (foo *_Null_unspecified)*v;");
8392 verifyFormat("x = (foo *_Nonnull)*v;");
8393 verifyFormat("x = (foo *[[clang::attr]])*v;");
8394 verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8395 verifyFormat("x = (foo *__ptr32)*v;");
8396 verifyFormat("x = (foo *__ptr64)*v;");
8397 verifyFormat("x = (foo *__capability)*v;");
8398
8399 // Check that we handle multiple trailing qualifiers and skip them all to
8400 // determine that the expression is a cast to a pointer type.
8401 FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8402 FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8403 LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8404 StringRef AllQualifiers =
8405 "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8406 "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8407 verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8408 verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8409
8410 // Also check that address-of is not parsed as a binary bitwise-and:
8411 verifyFormat("x = (foo *const)&v;");
8412 verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8413 verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8414
8415 // Check custom qualifiers:
8416 FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8417 CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8418 verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8419 verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8420 verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8421 CustomQualifier);
8422 verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8423 CustomQualifier);
8424
8425 // Check that unknown identifiers result in binary operator parsing:
8426 verifyFormat("x = (foo * __unknown_qualifier) * v;");
8427 verifyFormat("x = (foo * __unknown_qualifier) & v;");
8428}
8429
8430TEST_F(FormatTest, UnderstandsSquareAttributes) {
8431 verifyFormat("SomeType s [[unused]] (InitValue);");
8432 verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8433 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8434 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8435 verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8436 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8437 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8438 verifyFormat("[[nodiscard]] bool f() { return false; }");
8439 verifyFormat("class [[nodiscard]] f {\npublic:\n f() {}\n}");
8440 verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n f() {}\n}");
8441 verifyFormat("class [[gnu::unused]] f {\npublic:\n f() {}\n}");
8442
8443 // Make sure we do not mistake attributes for array subscripts.
8444 verifyFormat("int a() {}\n"
8445 "[[unused]] int b() {}\n");
8446 verifyFormat("NSArray *arr;\n"
8447 "arr[[Foo() bar]];");
8448
8449 // On the other hand, we still need to correctly find array subscripts.
8450 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8451
8452 // Make sure that we do not mistake Objective-C method inside array literals
8453 // as attributes, even if those method names are also keywords.
8454 verifyFormat("@[ [foo bar] ];");
8455 verifyFormat("@[ [NSArray class] ];");
8456 verifyFormat("@[ [foo enum] ];");
8457
8458 verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8459
8460 // Make sure we do not parse attributes as lambda introducers.
8461 FormatStyle MultiLineFunctions = getLLVMStyle();
8462 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8463 verifyFormat("[[unused]] int b() {\n"
8464 " return 42;\n"
8465 "}\n",
8466 MultiLineFunctions);
8467}
8468
8469TEST_F(FormatTest, AttributeClass) {
8470 FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8471 verifyFormat("class S {\n"
8472 " S(S&&) = default;\n"
8473 "};",
8474 Style);
8475 verifyFormat("class [[nodiscard]] S {\n"
8476 " S(S&&) = default;\n"
8477 "};",
8478 Style);
8479 verifyFormat("class __attribute((maybeunused)) S {\n"
8480 " S(S&&) = default;\n"
8481 "};",
8482 Style);
8483 verifyFormat("struct S {\n"
8484 " S(S&&) = default;\n"
8485 "};",
8486 Style);
8487 verifyFormat("struct [[nodiscard]] S {\n"
8488 " S(S&&) = default;\n"
8489 "};",
8490 Style);
8491}
8492
8493TEST_F(FormatTest, AttributesAfterMacro) {
8494 FormatStyle Style = getLLVMStyle();
8495 verifyFormat("MACRO;\n"
8496 "__attribute__((maybe_unused)) int foo() {\n"
8497 " //...\n"
8498 "}");
8499
8500 verifyFormat("MACRO;\n"
8501 "[[nodiscard]] int foo() {\n"
8502 " //...\n"
8503 "}");
8504
8505 EXPECT_EQ("MACRO\n\n"
8506 "__attribute__((maybe_unused)) int foo() {\n"
8507 " //...\n"
8508 "}",
8509 format("MACRO\n\n"
8510 "__attribute__((maybe_unused)) int foo() {\n"
8511 " //...\n"
8512 "}"));
8513
8514 EXPECT_EQ("MACRO\n\n"
8515 "[[nodiscard]] int foo() {\n"
8516 " //...\n"
8517 "}",
8518 format("MACRO\n\n"
8519 "[[nodiscard]] int foo() {\n"
8520 " //...\n"
8521 "}"));
8522}
8523
8524TEST_F(FormatTest, AttributePenaltyBreaking) {
8525 FormatStyle Style = getLLVMStyle();
8526 verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8527 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8528 Style);
8529 verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8530 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8531 Style);
8532 verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8533 "shared_ptr<ALongTypeName> &C d) {\n}",
8534 Style);
8535}
8536
8537TEST_F(FormatTest, UnderstandsEllipsis) {
8538 FormatStyle Style = getLLVMStyle();
8539 verifyFormat("int printf(const char *fmt, ...);");
8540 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8541 verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8542
8543 verifyFormat("template <int *...PP> a;", Style);
8544
8545 Style.PointerAlignment = FormatStyle::PAS_Left;
8546 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8547
8548 verifyFormat("template <int*... PP> a;", Style);
8549
8550 Style.PointerAlignment = FormatStyle::PAS_Middle;
8551 verifyFormat("template <int *... PP> a;", Style);
8552}
8553
8554TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8555 EXPECT_EQ("int *a;\n"
8556 "int *a;\n"
8557 "int *a;",
8558 format("int *a;\n"
8559 "int* a;\n"
8560 "int *a;",
8561 getGoogleStyle()));
8562 EXPECT_EQ("int* a;\n"
8563 "int* a;\n"
8564 "int* a;",
8565 format("int* a;\n"
8566 "int* a;\n"
8567 "int *a;",
8568 getGoogleStyle()));
8569 EXPECT_EQ("int *a;\n"
8570 "int *a;\n"
8571 "int *a;",
8572 format("int *a;\n"
8573 "int * a;\n"
8574 "int * a;",
8575 getGoogleStyle()));
8576 EXPECT_EQ("auto x = [] {\n"
8577 " int *a;\n"
8578 " int *a;\n"
8579 " int *a;\n"
8580 "};",
8581 format("auto x=[]{int *a;\n"
8582 "int * a;\n"
8583 "int * a;};",
8584 getGoogleStyle()));
8585}
8586
8587TEST_F(FormatTest, UnderstandsRvalueReferences) {
8588 verifyFormat("int f(int &&a) {}");
8589 verifyFormat("int f(int a, char &&b) {}");
8590 verifyFormat("void f() { int &&a = b; }");
8591 verifyGoogleFormat("int f(int a, char&& b) {}");
8592 verifyGoogleFormat("void f() { int&& a = b; }");
8593
8594 verifyIndependentOfContext("A<int &&> a;");
8595 verifyIndependentOfContext("A<int &&, int &&> a;");
8596 verifyGoogleFormat("A<int&&> a;");
8597 verifyGoogleFormat("A<int&&, int&&> a;");
8598
8599 // Not rvalue references:
8600 verifyFormat("template <bool B, bool C> class A {\n"
8601 " static_assert(B && C, \"Something is wrong\");\n"
8602 "};");
8603 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8604 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8605 verifyFormat("#define A(a, b) (a && b)");
8606}
8607
8608TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8609 verifyFormat("void f() {\n"
8610 " x[aaaaaaaaa -\n"
8611 " b] = 23;\n"
8612 "}",
8613 getLLVMStyleWithColumns(15));
8614}
8615
8616TEST_F(FormatTest, FormatsCasts) {
8617 verifyFormat("Type *A = static_cast<Type *>(P);");
8618 verifyFormat("Type *A = (Type *)P;");
8619 verifyFormat("Type *A = (vector<Type *, int *>)P;");
8620 verifyFormat("int a = (int)(2.0f);");
8621 verifyFormat("int a = (int)2.0f;");
8622 verifyFormat("x[(int32)y];");
8623 verifyFormat("x = (int32)y;");
8624 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8625 verifyFormat("int a = (int)*b;");
8626 verifyFormat("int a = (int)2.0f;");
8627 verifyFormat("int a = (int)~0;");
8628 verifyFormat("int a = (int)++a;");
8629 verifyFormat("int a = (int)sizeof(int);");
8630 verifyFormat("int a = (int)+2;");
8631 verifyFormat("my_int a = (my_int)2.0f;");
8632 verifyFormat("my_int a = (my_int)sizeof(int);");
8633 verifyFormat("return (my_int)aaa;");
8634 verifyFormat("#define x ((int)-1)");
8635 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8636 verifyFormat("#define p(q) ((int *)&q)");
8637 verifyFormat("fn(a)(b) + 1;");
8638
8639 verifyFormat("void f() { my_int a = (my_int)*b; }");
8640 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8641 verifyFormat("my_int a = (my_int)~0;");
8642 verifyFormat("my_int a = (my_int)++a;");
8643 verifyFormat("my_int a = (my_int)-2;");
8644 verifyFormat("my_int a = (my_int)1;");
8645 verifyFormat("my_int a = (my_int *)1;");
8646 verifyFormat("my_int a = (const my_int)-1;");
8647 verifyFormat("my_int a = (const my_int *)-1;");
8648 verifyFormat("my_int a = (my_int)(my_int)-1;");
8649 verifyFormat("my_int a = (ns::my_int)-2;");
8650 verifyFormat("case (my_int)ONE:");
8651 verifyFormat("auto x = (X)this;");
8652 // Casts in Obj-C style calls used to not be recognized as such.
8653 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8654
8655 // FIXME: single value wrapped with paren will be treated as cast.
8656 verifyFormat("void f(int i = (kValue)*kMask) {}");
8657
8658 verifyFormat("{ (void)F; }");
8659
8660 // Don't break after a cast's
8661 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8662 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8663 " bbbbbbbbbbbbbbbbbbbbbb);");
8664
8665 // These are not casts.
8666 verifyFormat("void f(int *) {}");
8667 verifyFormat("f(foo)->b;");
8668 verifyFormat("f(foo).b;");
8669 verifyFormat("f(foo)(b);");
8670 verifyFormat("f(foo)[b];");
8671 verifyFormat("[](foo) { return 4; }(bar);");
8672 verifyFormat("(*funptr)(foo)[4];");
8673 verifyFormat("funptrs[4](foo)[4];");
8674 verifyFormat("void f(int *);");
8675 verifyFormat("void f(int *) = 0;");
8676 verifyFormat("void f(SmallVector<int>) {}");
8677 verifyFormat("void f(SmallVector<int>);");
8678 verifyFormat("void f(SmallVector<int>) = 0;");
8679 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8680 verifyFormat("int a = sizeof(int) * b;");
8681 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8682 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8683 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8684 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8685
8686 // These are not casts, but at some point were confused with casts.
8687 verifyFormat("virtual void foo(int *) override;");
8688 verifyFormat("virtual void foo(char &) const;");
8689 verifyFormat("virtual void foo(int *a, char *) const;");
8690 verifyFormat("int a = sizeof(int *) + b;");
8691 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8692 verifyFormat("bool b = f(g<int>) && c;");
8693 verifyFormat("typedef void (*f)(int i) func;");
8694 verifyFormat("void operator++(int) noexcept;");
8695 verifyFormat("void operator++(int &) noexcept;");
8696 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8697 "&) noexcept;");
8698 verifyFormat(
8699 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8700 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8701 verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8702 verifyFormat("void operator delete(nothrow_t &) noexcept;");
8703 verifyFormat("void operator delete(foo &) noexcept;");
8704 verifyFormat("void operator delete(foo) noexcept;");
8705 verifyFormat("void operator delete(int) noexcept;");
8706 verifyFormat("void operator delete(int &) noexcept;");
8707 verifyFormat("void operator delete(int &) volatile noexcept;");
8708 verifyFormat("void operator delete(int &) const");
8709 verifyFormat("void operator delete(int &) = default");
8710 verifyFormat("void operator delete(int &) = delete");
8711 verifyFormat("void operator delete(int &) [[noreturn]]");
8712 verifyFormat("void operator delete(int &) throw();");
8713 verifyFormat("void operator delete(int &) throw(int);");
8714 verifyFormat("auto operator delete(int &) -> int;");
8715 verifyFormat("auto operator delete(int &) override");
8716 verifyFormat("auto operator delete(int &) final");
8717
8718 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8719 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8720 // FIXME: The indentation here is not ideal.
8721 verifyFormat(
8722 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8723 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8724 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8725}
8726
8727TEST_F(FormatTest, FormatsFunctionTypes) {
8728 verifyFormat("A<bool()> a;");
8729 verifyFormat("A<SomeType()> a;");
8730 verifyFormat("A<void (*)(int, std::string)> a;");
8731 verifyFormat("A<void *(int)>;");
8732 verifyFormat("void *(*a)(int *, SomeType *);");
8733 verifyFormat("int (*func)(void *);");
8734 verifyFormat("void f() { int (*func)(void *); }");
8735 verifyFormat("template <class CallbackClass>\n"
8736 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8737
8738 verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8739 verifyGoogleFormat("void* (*a)(int);");
8740 verifyGoogleFormat(
8741 "template <class CallbackClass>\n"
8742 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8743
8744 // Other constructs can look somewhat like function types:
8745 verifyFormat("A<sizeof(*x)> a;");
8746 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8747 verifyFormat("some_var = function(*some_pointer_var)[0];");
8748 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8749 verifyFormat("int x = f(&h)();");
8750 verifyFormat("returnsFunction(&param1, &param2)(param);");
8751 verifyFormat("std::function<\n"
8752 " LooooooooooongTemplatedType<\n"
8753 " SomeType>*(\n"
8754 " LooooooooooooooooongType type)>\n"
8755 " function;",
8756 getGoogleStyleWithColumns(40));
8757}
8758
8759TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8760 verifyFormat("A (*foo_)[6];");
8761 verifyFormat("vector<int> (*foo_)[6];");
8762}
8763
8764TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8765 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8766 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
8767 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8768 " LoooooooooooooooooooooooooooooooooooooooongVariable;");
8769 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8770 " *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8771
8772 // Different ways of ()-initializiation.
8773 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8774 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8775 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8776 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8777 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8778 " LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8779 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8780 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8781
8782 // Lambdas should not confuse the variable declaration heuristic.
8783 verifyFormat("LooooooooooooooooongType\n"
8784 " variable(nullptr, [](A *a) {});",
8785 getLLVMStyleWithColumns(40));
8786}
8787
8788TEST_F(FormatTest, BreaksLongDeclarations) {
8789 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8790 " AnotherNameForTheLongType;");
8791 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8793 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8794 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8795 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8796 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8797 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8798 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8799 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8800 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8801 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8802 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8803 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8804 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8805 verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8806 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8807 verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8808 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8809 verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8810 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8811 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8812 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8813 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8814 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8815 FormatStyle Indented = getLLVMStyle();
8816 Indented.IndentWrappedFunctionNames = true;
8817 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8818 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8819 Indented);
8820 verifyFormat(
8821 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8822 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8823 Indented);
8824 verifyFormat(
8825 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8826 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8827 Indented);
8828 verifyFormat(
8829 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8830 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8831 Indented);
8832
8833 // FIXME: Without the comment, this breaks after "(".
8834 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
8835 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8836 getGoogleStyle());
8837
8838 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8839 " int LoooooooooooooooooooongParam2) {}");
8840 verifyFormat(
8841 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8842 " SourceLocation L, IdentifierIn *II,\n"
8843 " Type *T) {}");
8844 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8845 "ReallyReaaallyLongFunctionName(\n"
8846 " const std::string &SomeParameter,\n"
8847 " const SomeType<string, SomeOtherTemplateParameter>\n"
8848 " &ReallyReallyLongParameterName,\n"
8849 " const SomeType<string, SomeOtherTemplateParameter>\n"
8850 " &AnotherLongParameterName) {}");
8851 verifyFormat("template <typename A>\n"
8852 "SomeLoooooooooooooooooooooongType<\n"
8853 " typename some_namespace::SomeOtherType<A>::Type>\n"
8854 "Function() {}");
8855
8856 verifyGoogleFormat(
8857 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8858 " aaaaaaaaaaaaaaaaaaaaaaa;");
8859 verifyGoogleFormat(
8860 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8861 " SourceLocation L) {}");
8862 verifyGoogleFormat(
8863 "some_namespace::LongReturnType\n"
8864 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8865 " int first_long_parameter, int second_parameter) {}");
8866
8867 verifyGoogleFormat("template <typename T>\n"
8868 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8869 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8870 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8871 " int aaaaaaaaaaaaaaaaaaaaaaa);");
8872
8873 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8874 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8875 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8876 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8877 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8878 " aaaaaaaaaaaaaaaaaaaaaaaa);");
8879 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8880 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8882 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8883
8884 verifyFormat("template <typename T> // Templates on own line.\n"
8885 "static int // Some comment.\n"
8886 "MyFunction(int a);",
8887 getLLVMStyle());
8888}
8889
8890TEST_F(FormatTest, FormatsAccessModifiers) {
8891 FormatStyle Style = getLLVMStyle();
8892 EXPECT_EQ(Style.EmptyLineBeforeAccessModifier,
8893 FormatStyle::ELBAMS_LogicalBlock);
8894 verifyFormat("struct foo {\n"
8895 "private:\n"
8896 " void f() {}\n"
8897 "\n"
8898 "private:\n"
8899 " int i;\n"
8900 "\n"
8901 "protected:\n"
8902 " int j;\n"
8903 "};\n",
8904 Style);
8905 verifyFormat("struct foo {\n"
8906 "private:\n"
8907 " void f() {}\n"
8908 "\n"
8909 "private:\n"
8910 " int i;\n"
8911 "\n"
8912 "protected:\n"
8913 " int j;\n"
8914 "};\n",
8915 "struct foo {\n"
8916 "private:\n"
8917 " void f() {}\n"
8918 "private:\n"
8919 " int i;\n"
8920 "protected:\n"
8921 " int j;\n"
8922 "};\n",
8923 Style);
8924 verifyFormat("struct foo { /* comment */\n"
8925 "private:\n"
8926 " int i;\n"
8927 " // comment\n"
8928 "private:\n"
8929 " int j;\n"
8930 "};\n",
8931 Style);
8932 verifyFormat("struct foo {\n"
8933 "#ifdef FOO\n"
8934 "#endif\n"
8935 "private:\n"
8936 " int i;\n"
8937 "#ifdef FOO\n"
8938 "private:\n"
8939 "#endif\n"
8940 " int j;\n"
8941 "};\n",
8942 Style);
8943 Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
8944 verifyFormat("struct foo {\n"
8945 "private:\n"
8946 " void f() {}\n"
8947 "private:\n"
8948 " int i;\n"
8949 "protected:\n"
8950 " int j;\n"
8951 "};\n",
8952 Style);
8953 verifyFormat("struct foo {\n"
8954 "private:\n"
8955 " void f() {}\n"
8956 "private:\n"
8957 " int i;\n"
8958 "protected:\n"
8959 " int j;\n"
8960 "};\n",
8961 "struct foo {\n"
8962 "\n"
8963 "private:\n"
8964 " void f() {}\n"
8965 "\n"
8966 "private:\n"
8967 " int i;\n"
8968 "\n"
8969 "protected:\n"
8970 " int j;\n"
8971 "};\n",
8972 Style);
8973 verifyFormat("struct foo { /* comment */\n"
8974 "private:\n"
8975 " int i;\n"
8976 " // comment\n"
8977 "private:\n"
8978 " int j;\n"
8979 "};\n",
8980 "struct foo { /* comment */\n"
8981 "\n"
8982 "private:\n"
8983 " int i;\n"
8984 " // comment\n"
8985 "\n"
8986 "private:\n"
8987 " int j;\n"
8988 "};\n",
8989 Style);
8990 verifyFormat("struct foo {\n"
8991 "#ifdef FOO\n"
8992 "#endif\n"
8993 "private:\n"
8994 " int i;\n"
8995 "#ifdef FOO\n"
8996 "private:\n"
8997 "#endif\n"
8998 " int j;\n"
8999 "};\n",
9000 "struct foo {\n"
9001 "#ifdef FOO\n"
9002 "#endif\n"
9003 "\n"
9004 "private:\n"
9005 " int i;\n"
9006 "#ifdef FOO\n"
9007 "\n"
9008 "private:\n"
9009 "#endif\n"
9010 " int j;\n"
9011 "};\n",
9012 Style);
9013 Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
9014 verifyFormat("struct foo {\n"
9015 "private:\n"
9016 " void f() {}\n"
9017 "\n"
9018 "private:\n"
9019 " int i;\n"
9020 "\n"
9021 "protected:\n"
9022 " int j;\n"
9023 "};\n",
9024 Style);
9025 verifyFormat("struct foo {\n"
9026 "private:\n"
9027 " void f() {}\n"
9028 "\n"
9029 "private:\n"
9030 " int i;\n"
9031 "\n"
9032 "protected:\n"
9033 " int j;\n"
9034 "};\n",
9035 "struct foo {\n"
9036 "private:\n"
9037 " void f() {}\n"
9038 "private:\n"
9039 " int i;\n"
9040 "protected:\n"
9041 " int j;\n"
9042 "};\n",
9043 Style);
9044 verifyFormat("struct foo { /* comment */\n"
9045 "private:\n"
9046 " int i;\n"
9047 " // comment\n"
9048 "\n"
9049 "private:\n"
9050 " int j;\n"
9051 "};\n",
9052 "struct foo { /* comment */\n"
9053 "private:\n"
9054 " int i;\n"
9055 " // comment\n"
9056 "\n"
9057 "private:\n"
9058 " int j;\n"
9059 "};\n",
9060 Style);
9061 verifyFormat("struct foo {\n"
9062 "#ifdef FOO\n"
9063 "#endif\n"
9064 "\n"
9065 "private:\n"
9066 " int i;\n"
9067 "#ifdef FOO\n"
9068 "\n"
9069 "private:\n"
9070 "#endif\n"
9071 " int j;\n"
9072 "};\n",
9073 "struct foo {\n"
9074 "#ifdef FOO\n"
9075 "#endif\n"
9076 "private:\n"
9077 " int i;\n"
9078 "#ifdef FOO\n"
9079 "private:\n"
9080 "#endif\n"
9081 " int j;\n"
9082 "};\n",
9083 Style);
9084 Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
9085 EXPECT_EQ("struct foo {\n"
9086 "\n"
9087 "private:\n"
9088 " void f() {}\n"
9089 "\n"
9090 "private:\n"
9091 " int i;\n"
9092 "\n"
9093 "protected:\n"
9094 " int j;\n"
9095 "};\n",
9096 format("struct foo {\n"
9097 "\n"
9098 "private:\n"
9099 " void f() {}\n"
9100 "\n"
9101 "private:\n"
9102 " int i;\n"
9103 "\n"
9104 "protected:\n"
9105 " int j;\n"
9106 "};\n",
9107 Style));
9108 verifyFormat("struct foo {\n"
9109 "private:\n"
9110 " void f() {}\n"
9111 "private:\n"
9112 " int i;\n"
9113 "protected:\n"
9114 " int j;\n"
9115 "};\n",
9116 Style);
9117 EXPECT_EQ("struct foo { /* comment */\n"
9118 "\n"
9119 "private:\n"
9120 " int i;\n"
9121 " // comment\n"
9122 "\n"
9123 "private:\n"
9124 " int j;\n"
9125 "};\n",
9126 format("struct foo { /* comment */\n"
9127 "\n"
9128 "private:\n"
9129 " int i;\n"
9130 " // comment\n"
9131 "\n"
9132 "private:\n"
9133 " int j;\n"
9134 "};\n",
9135 Style));
9136 verifyFormat("struct foo { /* comment */\n"
9137 "private:\n"
9138 " int i;\n"
9139 " // comment\n"
9140 "private:\n"
9141 " int j;\n"
9142 "};\n",
9143 Style);
9144 EXPECT_EQ("struct foo {\n"
9145 "#ifdef FOO\n"
9146 "#endif\n"
9147 "\n"
9148 "private:\n"
9149 " int i;\n"
9150 "#ifdef FOO\n"
9151 "\n"
9152 "private:\n"
9153 "#endif\n"
9154 " int j;\n"
9155 "};\n",
9156 format("struct foo {\n"
9157 "#ifdef FOO\n"
9158 "#endif\n"
9159 "\n"
9160 "private:\n"
9161 " int i;\n"
9162 "#ifdef FOO\n"
9163 "\n"
9164 "private:\n"
9165 "#endif\n"
9166 " int j;\n"
9167 "};\n",
9168 Style));
9169 verifyFormat("struct foo {\n"
9170 "#ifdef FOO\n"
9171 "#endif\n"
9172 "private:\n"
9173 " int i;\n"
9174 "#ifdef FOO\n"
9175 "private:\n"
9176 "#endif\n"
9177 " int j;\n"
9178 "};\n",
9179 Style);
9180}
9181
9182TEST_F(FormatTest, FormatsArrays) {
9183 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9184 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
9185 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
9186 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
9187 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
9188 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
9189 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9190 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
9191 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9192 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
9193 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9194 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9195 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
9196 verifyFormat(
9197 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
9198 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9199 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
9200 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
9201 " .aaaaaaaaaaaaaaaaaaaaaa();");
9202
9203 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
9204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
9205 verifyFormat(
9206 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
9207 " .aaaaaaa[0]\n"
9208 " .aaaaaaaaaaaaaaaaaaaaaa();");
9209 verifyFormat("a[::b::c];");
9210
9211 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
9212
9213 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
9214 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
9215}
9216
9217TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
9218 verifyFormat("(a)->b();");
9219 verifyFormat("--a;");
9220}
9221
9222TEST_F(FormatTest, HandlesIncludeDirectives) {
9223 verifyFormat("#include <string>\n"
9224 "#include <a/b/c.h>\n"
9225 "#include \"a/b/string\"\n"
9226 "#include \"string.h\"\n"
9227 "#include \"string.h\"\n"
9228 "#include <a-a>\n"
9229 "#include < path with space >\n"
9230 "#include_next <test.h>"
9231 "#include \"abc.h\" // this is included for ABC\n"
9232 "#include \"some long include\" // with a comment\n"
9233 "#include \"some very long include path\"\n"
9234 "#include <some/very/long/include/path>\n",
9235 getLLVMStyleWithColumns(35));
9236 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));
9237 EXPECT_EQ("#include <a>", format("#include<a>"));
9238
9239 verifyFormat("#import <string>");
9240 verifyFormat("#import <a/b/c.h>");
9241 verifyFormat("#import \"a/b/string\"");
9242 verifyFormat("#import \"string.h\"");
9243 verifyFormat("#import \"string.h\"");
9244 verifyFormat("#if __has_include(<strstream>)\n"
9245 "#include <strstream>\n"
9246 "#endif");
9247
9248 verifyFormat("#define MY_IMPORT <a/b>");
9249
9250 verifyFormat("#if __has_include(<a/b>)");
9251 verifyFormat("#if __has_include_next(<a/b>)");
9252 verifyFormat("#define F __has_include(<a/b>)");
9253 verifyFormat("#define F __has_include_next(<a/b>)");
9254
9255 // Protocol buffer definition or missing "#".
9256 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
9257 getLLVMStyleWithColumns(30));
9258
9259 FormatStyle Style = getLLVMStyle();
9260 Style.AlwaysBreakBeforeMultilineStrings = true;
9261 Style.ColumnLimit = 0;
9262 verifyFormat("#import \"abc.h\"", Style);
9263
9264 // But 'import' might also be a regular C++ namespace.
9265 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
9267}
9268
9269//===----------------------------------------------------------------------===//
9270// Error recovery tests.
9271//===----------------------------------------------------------------------===//
9272
9273TEST_F(FormatTest, IncompleteParameterLists) {
9274 FormatStyle NoBinPacking = getLLVMStyle();
9275 NoBinPacking.BinPackParameters = false;
9276 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
9277 " double *min_x,\n"
9278 " double *max_x,\n"
9279 " double *min_y,\n"
9280 " double *max_y,\n"
9281 " double *min_z,\n"
9282 " double *max_z, ) {}",
9283 NoBinPacking);
9284}
9285
9286TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
9287 verifyFormat("void f() { return; }\n42");
9288 verifyFormat("void f() {\n"
9289 " if (0)\n"
9290 " return;\n"
9291 "}\n"
9292 "42");
9293 verifyFormat("void f() { return }\n42");
9294 verifyFormat("void f() {\n"
9295 " if (0)\n"
9296 " return\n"
9297 "}\n"
9298 "42");
9299}
9300
9301TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
9302 EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));
9303 EXPECT_EQ("void f() {\n"
9304 " if (a)\n"
9305 " return\n"
9306 "}",
9307 format("void f ( ) { if ( a ) return }"));
9308 EXPECT_EQ("namespace N {\n"
9309 "void f()\n"
9310 "}",
9311 format("namespace N { void f() }"));
9312 EXPECT_EQ("namespace N {\n"
9313 "void f() {}\n"
9314 "void g()\n"
9315 "} // namespace N",
9316 format("namespace N { void f( ) { } void g( ) }"));
9317}
9318
9319TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
9320 verifyFormat("int aaaaaaaa =\n"
9321 " // Overlylongcomment\n"
9322 " b;",
9323 getLLVMStyleWithColumns(20));
9324 verifyFormat("function(\n"
9325 " ShortArgument,\n"
9326 " LoooooooooooongArgument);\n",
9327 getLLVMStyleWithColumns(20));
9328}
9329
9330TEST_F(FormatTest, IncorrectAccessSpecifier) {
9331 verifyFormat("public:");
9332 verifyFormat("class A {\n"
9333 "public\n"
9334 " void f() {}\n"
9335 "};");
9336 verifyFormat("public\n"
9337 "int qwerty;");
9338 verifyFormat("public\n"
9339 "B {}");
9340 verifyFormat("public\n"
9341 "{}");
9342 verifyFormat("public\n"
9343 "B { int x; }");
9344}
9345
9346TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
9347 verifyFormat("{");
9348 verifyFormat("#})");
9349 verifyNoCrash("(/**/[:!] ?[).");
9350}
9351
9352TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
9353 // Found by oss-fuzz:
9354 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
9355 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
9356 Style.ColumnLimit = 60;
9357 verifyNoCrash(
9358 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
9359 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
9360 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
9361 Style);
9362}
9363
9364TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
9365 verifyFormat("do {\n}");
9366 verifyFormat("do {\n}\n"
9367 "f();");
9368 verifyFormat("do {\n}\n"
9369 "wheeee(fun);");
9370 verifyFormat("do {\n"
9371 " f();\n"
9372 "}");
9373}
9374
9375TEST_F(FormatTest, IncorrectCodeMissingParens) {
9376 verifyFormat("if {\n foo;\n foo();\n}");
9377 verifyFormat("switch {\n foo;\n foo();\n}");
9378 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
9379 verifyFormat("while {\n foo;\n foo();\n}");
9380 verifyFormat("do {\n foo;\n foo();\n} while;");
9381}
9382
9383TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9384 verifyIncompleteFormat("namespace {\n"
9385 "class Foo { Foo (\n"
9386 "};\n"
9387 "} // namespace");
9388}
9389
9390TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9391 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n"));
9392 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n"));
9393 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n"));
9394 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n"));
9395
9396 EXPECT_EQ("{\n"
9397 " {\n"
9398 " breakme(\n"
9399 " qwe);\n"
9400 " }\n",
9401 format("{\n"
9402 " {\n"
9403 " breakme(qwe);\n"
9404 "}\n",
9405 getLLVMStyleWithColumns(10)));
9406}
9407
9408TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9409 verifyFormat("int x = {\n"
9410 " avariable,\n"
9411 " b(alongervariable)};",
9412 getLLVMStyleWithColumns(25));
9413}
9414
9415TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9416 verifyFormat("return (a)(b){1, 2, 3};");
9417}
9418
9419TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9420 verifyFormat("vector<int> x{1, 2, 3, 4};");
9421 verifyFormat("vector<int> x{\n"
9422 " 1,\n"
9423 " 2,\n"
9424 " 3,\n"
9425 " 4,\n"
9426 "};");
9427 verifyFormat("vector<T> x{{}, {}, {}, {}};");
9428 verifyFormat("f({1, 2});");
9429 verifyFormat("auto v = Foo{-1};");
9430 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9431 verifyFormat("Class::Class : member{1, 2, 3} {}");
9432 verifyFormat("new vector<int>{1, 2, 3};");
9433 verifyFormat("new int[3]{1, 2, 3};");
9434 verifyFormat("new int{1};");
9435 verifyFormat("return {arg1, arg2};");
9436 verifyFormat("return {arg1, SomeType{parameter}};");
9437 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9438 verifyFormat("new T{arg1, arg2};");
9439 verifyFormat("f(MyMap[{composite, key}]);");
9440 verifyFormat("class Class {\n"
9441 " T member = {arg1, arg2};\n"
9442 "};");
9443 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9444 verifyFormat("const struct A a = {.a = 1, .b = 2};");
9445 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9446 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9447 verifyFormat("int a = std::is_integral<int>{} + 0;");
9448
9449 verifyFormat("int foo(int i) { return fo1{}(i); }");
9450 verifyFormat("int foo(int i) { return fo1{}(i); }");
9451 verifyFormat("auto i = decltype(x){};");
9452 verifyFormat("auto i = typeof(x){};");
9453 verifyFormat("auto i = _Atomic(x){};");
9454 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9455 verifyFormat("Node n{1, Node{1000}, //\n"
9456 " 2};");
9457 verifyFormat("Aaaa aaaaaaa{\n"
9458 " {\n"
9459 " aaaa,\n"
9460 " },\n"
9461 "};");
9462 verifyFormat("class C : public D {\n"
9463 " SomeClass SC{2};\n"
9464 "};");
9465 verifyFormat("class C : public A {\n"
9466 " class D : public B {\n"
9467 " void f() { int i{2}; }\n"
9468 " };\n"
9469 "};");
9470 verifyFormat("#define A {a, a},");
9471
9472 // Avoid breaking between equal sign and opening brace
9473 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9474 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9475 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9476 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9477 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9478 " {\"ccccccccccccccccccccc\", 2}};",
9479 AvoidBreakingFirstArgument);
9480
9481 // Binpacking only if there is no trailing comma
9482 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9483 " cccccccccc, dddddddddd};",
9484 getLLVMStyleWithColumns(50));
9485 verifyFormat("const Aaaaaa aaaaa = {\n"
9486 " aaaaaaaaaaa,\n"
9487 " bbbbbbbbbbb,\n"
9488 " ccccccccccc,\n"
9489 " ddddddddddd,\n"
9490 "};",
9491 getLLVMStyleWithColumns(50));
9492
9493 // Cases where distinguising braced lists and blocks is hard.
9494 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9495 verifyFormat("void f() {\n"
9496 " return; // comment\n"
9497 "}\n"
9498 "SomeType t;");
9499 verifyFormat("void f() {\n"
9500 " if (a) {\n"
9501 " f();\n"
9502 " }\n"
9503 "}\n"
9504 "SomeType t;");
9505
9506 // In combination with BinPackArguments = false.
9507 FormatStyle NoBinPacking = getLLVMStyle();
9508 NoBinPacking.BinPackArguments = false;
9509 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9510 " bbbbb,\n"
9511 " ccccc,\n"
9512 " ddddd,\n"
9513 " eeeee,\n"
9514 " ffffff,\n"
9515 " ggggg,\n"
9516 " hhhhhh,\n"
9517 " iiiiii,\n"
9518 " jjjjjj,\n"
9519 " kkkkkk};",
9520 NoBinPacking);
9521 verifyFormat("const Aaaaaa aaaaa = {\n"
9522 " aaaaa,\n"
9523 " bbbbb,\n"
9524 " ccccc,\n"
9525 " ddddd,\n"
9526 " eeeee,\n"
9527 " ffffff,\n"
9528 " ggggg,\n"
9529 " hhhhhh,\n"
9530 " iiiiii,\n"
9531 " jjjjjj,\n"
9532 " kkkkkk,\n"
9533 "};",
9534 NoBinPacking);
9535 verifyFormat(
9536 "const Aaaaaa aaaaa = {\n"
9537 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
9538 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
9539 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9540 "};",
9541 NoBinPacking);
9542
9543 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9544 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9545 " CDDDP83848_BMCR_REGISTER,\n"
9546 " CDDDP83848_BMSR_REGISTER,\n"
9547 " CDDDP83848_RBR_REGISTER};",
9548 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9549 " CDDDP83848_BMSR_REGISTER,\n"
9550 " CDDDP83848_RBR_REGISTER};",
9551 NoBinPacking));
9552
9553 // FIXME: The alignment of these trailing comments might be bad. Then again,
9554 // this might be utterly useless in real code.
9555 verifyFormat("Constructor::Constructor()\n"
9556 " : some_value{ //\n"
9557 " aaaaaaa, //\n"
9558 " bbbbbbb} {}");
9559
9560 // In braced lists, the first comment is always assumed to belong to the
9561 // first element. Thus, it can be moved to the next or previous line as
9562 // appropriate.
9563 EXPECT_EQ("function({// First element:\n"
9564 " 1,\n"
9565 " // Second element:\n"
9566 " 2});",
9567 format("function({\n"
9568 " // First element:\n"
9569 " 1,\n"
9570 " // Second element:\n"
9571 " 2});"));
9572 EXPECT_EQ("std::vector<int> MyNumbers{\n"
9573 " // First element:\n"
9574 " 1,\n"
9575 " // Second element:\n"
9576 " 2};",
9577 format("std::vector<int> MyNumbers{// First element:\n"
9578 " 1,\n"
9579 " // Second element:\n"
9580 " 2};",
9581 getLLVMStyleWithColumns(30)));
9582 // A trailing comma should still lead to an enforced line break and no
9583 // binpacking.
9584 EXPECT_EQ("vector<int> SomeVector = {\n"
9585 " // aaa\n"
9586 " 1,\n"
9587 " 2,\n"
9588 "};",
9589 format("vector<int> SomeVector = { // aaa\n"
9590 " 1, 2, };"));
9591
9592 // C++11 brace initializer list l-braces should not be treated any differently
9593 // when breaking before lambda bodies is enabled
9594 FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9595 BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9596 BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9597 BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9598 verifyFormat(
9599 "std::runtime_error{\n"
9600 " \"Long string which will force a break onto the next line...\"};",
9601 BreakBeforeLambdaBody);
9602
9603 FormatStyle ExtraSpaces = getLLVMStyle();
9604 ExtraSpaces.Cpp11BracedListStyle = false;
9605 ExtraSpaces.ColumnLimit = 75;
9606 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9607 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9608 verifyFormat("f({ 1, 2 });", ExtraSpaces);
9609 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9610 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9611 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9612 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9613 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9614 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9615 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9616 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9617 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9618 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9619 verifyFormat("class Class {\n"
9620 " T member = { arg1, arg2 };\n"
9621 "};",
9622 ExtraSpaces);
9623 verifyFormat(
9624 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9625 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9626 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9627 " bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9628 ExtraSpaces);
9629 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9630 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9631 ExtraSpaces);
9632 verifyFormat(
9633 "someFunction(OtherParam,\n"
9634 " BracedList{ // comment 1 (Forcing interesting break)\n"
9635 " param1, param2,\n"
9636 " // comment 2\n"
9637 " param3, param4 });",
9638 ExtraSpaces);
9639 verifyFormat(
9640 "std::this_thread::sleep_for(\n"
9641 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9642 ExtraSpaces);
9643 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9644 " aaaaaaa,\n"
9645 " aaaaaaaaaa,\n"
9646 " aaaaa,\n"
9647 " aaaaaaaaaaaaaaa,\n"
9648 " aaa,\n"
9649 " aaaaaaaaaa,\n"
9650 " a,\n"
9651 " aaaaaaaaaaaaaaaaaaaaa,\n"
9652 " aaaaaaaaaaaa,\n"
9653 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9654 " aaaaaaa,\n"
9655 " a};");
9656 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9657 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9658 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9659
9660 // Avoid breaking between initializer/equal sign and opening brace
9661 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9662 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9663 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9664 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9665 " { \"ccccccccccccccccccccc\", 2 }\n"
9666 "};",
9667 ExtraSpaces);
9668 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9669 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9670 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9671 " { \"ccccccccccccccccccccc\", 2 }\n"
9672 "};",
9673 ExtraSpaces);
9674
9675 FormatStyle SpaceBeforeBrace = getLLVMStyle();
9676 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9677 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9678 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9679
9680 FormatStyle SpaceBetweenBraces = getLLVMStyle();
9681 SpaceBetweenBraces.SpacesInAngles = true;
9682 SpaceBetweenBraces.SpacesInParentheses = true;
9683 SpaceBetweenBraces.SpacesInSquareBrackets = true;
9684 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9685 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9686 verifyFormat("vector< int > x{ // comment 1\n"
9687 " 1, 2, 3, 4 };",
9688 SpaceBetweenBraces);
9689 SpaceBetweenBraces.ColumnLimit = 20;
9690 EXPECT_EQ("vector< int > x{\n"
9691 " 1, 2, 3, 4 };",
9692 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9693 SpaceBetweenBraces.ColumnLimit = 24;
9694 EXPECT_EQ("vector< int > x{ 1, 2,\n"
9695 " 3, 4 };",
9696 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9697 EXPECT_EQ("vector< int > x{\n"
9698 " 1,\n"
9699 " 2,\n"
9700 " 3,\n"
9701 " 4,\n"
9702 "};",
9703 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9704 verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9705 SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9706 verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9707}
9708
9709TEST_F(FormatTest, FormatSpacesInAngles) {
9710 FormatStyle SpaceInAngles = getLLVMStyle();
9711 SpaceInAngles.SpacesInAngles = true;
9712 verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9713 verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9714 verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9715
9716 SpaceInAngles.SpacesInAngles = false;
9717 verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9718 verifyFormat("vector<int> x5;", SpaceInAngles);
9719 verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9720 verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9721}
9722
9723TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9724 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9725 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9726 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9727 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9728 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9729 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
9730 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9731 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9732 " 1, 22, 333, 4444, 55555, //\n"
9733 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9734 " 1, 22, 333, 4444, 55555, 666666, 7777777};");
9735 verifyFormat(
9736 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9737 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9738 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
9739 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
9740 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
9741 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
9742 " 7777777};");
9743 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9744 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9745 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9746 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9747 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9748 " // Separating comment.\n"
9749 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9750 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9751 " // Leading comment\n"
9752 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9753 " X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9754 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9755 " 1, 1, 1, 1};",
9756 getLLVMStyleWithColumns(39));
9757 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9758 " 1, 1, 1, 1};",
9759 getLLVMStyleWithColumns(38));
9760 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9761 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9762 getLLVMStyleWithColumns(43));
9763 verifyFormat(
9764 "static unsigned SomeValues[10][3] = {\n"
9765 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
9766 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9767 verifyFormat("static auto fields = new vector<string>{\n"
9768 " \"aaaaaaaaaaaaa\",\n"
9769 " \"aaaaaaaaaaaaa\",\n"
9770 " \"aaaaaaaaaaaa\",\n"
9771 " \"aaaaaaaaaaaaaa\",\n"
9772 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9773 " \"aaaaaaaaaaaa\",\n"
9774 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9775 "};");
9776 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9777 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9778 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9779 " 3, cccccccccccccccccccccc};",
9780 getLLVMStyleWithColumns(60));
9781
9782 // Trailing commas.
9783 verifyFormat("vector<int> x = {\n"
9784 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
9785 "};",
9786 getLLVMStyleWithColumns(39));
9787 verifyFormat("vector<int> x = {\n"
9788 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
9789 "};",
9790 getLLVMStyleWithColumns(39));
9791 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9792 " 1, 1, 1, 1,\n"
9793 " /**/ /**/};",
9794 getLLVMStyleWithColumns(39));
9795
9796 // Trailing comment in the first line.
9797 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
9798 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
9799 " 111111111, 222222222, 3333333333, 444444444, //\n"
9800 " 11111111, 22222222, 333333333, 44444444};");
9801 // Trailing comment in the last line.
9802 verifyFormat("int aaaaa[] = {\n"
9803 " 1, 2, 3, // comment\n"
9804 " 4, 5, 6 // comment\n"
9805 "};");
9806
9807 // With nested lists, we should either format one item per line or all nested
9808 // lists one on line.
9809 // FIXME: For some nested lists, we can do better.
9810 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9811 " {aaaaaaaaaaaaaaaaaaa},\n"
9812 " {aaaaaaaaaaaaaaaaaaaaa},\n"
9813 " {aaaaaaaaaaaaaaaaa}};",
9814 getLLVMStyleWithColumns(60));
9815 verifyFormat(
9816 "SomeStruct my_struct_array = {\n"
9817 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9818 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9819 " {aaa, aaa},\n"
9820 " {aaa, aaa},\n"
9821 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9822 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9823 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9824
9825 // No column layout should be used here.
9826 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9827 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9828
9829 verifyNoCrash("a<,");
9830
9831 // No braced initializer here.
9832 verifyFormat("void f() {\n"
9833 " struct Dummy {};\n"
9834 " f(v);\n"
9835 "}");
9836
9837 // Long lists should be formatted in columns even if they are nested.
9838 verifyFormat(
9839 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9840 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9841 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9842 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9843 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9844 " 1, 22, 333, 4444, 55555, 666666, 7777777});");
9845
9846 // Allow "single-column" layout even if that violates the column limit. There
9847 // isn't going to be a better way.
9848 verifyFormat("std::vector<int> a = {\n"
9849 " aaaaaaaa,\n"
9850 " aaaaaaaa,\n"
9851 " aaaaaaaa,\n"
9852 " aaaaaaaa,\n"
9853 " aaaaaaaaaa,\n"
9854 " aaaaaaaa,\n"
9855 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9856 getLLVMStyleWithColumns(30));
9857 verifyFormat("vector<int> aaaa = {\n"
9858 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9859 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9860 " aaaaaa.aaaaaaa,\n"
9861 " aaaaaa.aaaaaaa,\n"
9862 " aaaaaa.aaaaaaa,\n"
9863 " aaaaaa.aaaaaaa,\n"
9864 "};");
9865
9866 // Don't create hanging lists.
9867 verifyFormat("someFunction(Param, {List1, List2,\n"
9868 " List3});",
9869 getLLVMStyleWithColumns(35));
9870 verifyFormat("someFunction(Param, Param,\n"
9871 " {List1, List2,\n"
9872 " List3});",
9873 getLLVMStyleWithColumns(35));
9874 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9875 " aaaaaaaaaaaaaaaaaaaaaaa);");
9876}
9877
9878TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9879 FormatStyle DoNotMerge = getLLVMStyle();
9880 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9881
9882 verifyFormat("void f() { return 42; }");
9883 verifyFormat("void f() {\n"
9884 " return 42;\n"
9885 "}",
9886 DoNotMerge);
9887 verifyFormat("void f() {\n"
9888 " // Comment\n"
9889 "}");
9890 verifyFormat("{\n"
9891 "#error {\n"
9892 " int a;\n"
9893 "}");
9894 verifyFormat("{\n"
9895 " int a;\n"
9896 "#error {\n"
9897 "}");
9898 verifyFormat("void f() {} // comment");
9899 verifyFormat("void f() { int a; } // comment");
9900 verifyFormat("void f() {\n"
9901 "} // comment",
9902 DoNotMerge);
9903 verifyFormat("void f() {\n"
9904 " int a;\n"
9905 "} // comment",
9906 DoNotMerge);
9907 verifyFormat("void f() {\n"
9908 "} // comment",
9909 getLLVMStyleWithColumns(15));
9910
9911 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9912 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
9913
9914 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9915 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9916 verifyFormat("class C {\n"
9917 " C()\n"
9918 " : iiiiiiii(nullptr),\n"
9919 " kkkkkkk(nullptr),\n"
9920 " mmmmmmm(nullptr),\n"
9921 " nnnnnnn(nullptr) {}\n"
9922 "};",
9923 getGoogleStyle());
9924
9925 FormatStyle NoColumnLimit = getLLVMStyle();
9926 NoColumnLimit.ColumnLimit = 0;
9927 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9928 EXPECT_EQ("class C {\n"
9929 " A() : b(0) {}\n"
9930 "};",
9931 format("class C{A():b(0){}};", NoColumnLimit));
9932 EXPECT_EQ("A()\n"
9933 " : b(0) {\n"
9934 "}",
9935 format("A()\n:b(0)\n{\n}", NoColumnLimit));
9936
9937 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9938 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9939 FormatStyle::SFS_None;
9940 EXPECT_EQ("A()\n"
9941 " : b(0) {\n"
9942 "}",
9943 format("A():b(0){}", DoNotMergeNoColumnLimit));
9944 EXPECT_EQ("A()\n"
9945 " : b(0) {\n"
9946 "}",
9947 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9948
9949 verifyFormat("#define A \\\n"
9950 " void f() { \\\n"
9951 " int i; \\\n"
9952 " }",
9953 getLLVMStyleWithColumns(20));
9954 verifyFormat("#define A \\\n"
9955 " void f() { int i; }",
9956 getLLVMStyleWithColumns(21));
9957 verifyFormat("#define A \\\n"
9958 " void f() { \\\n"
9959 " int i; \\\n"
9960 " } \\\n"
9961 " int j;",
9962 getLLVMStyleWithColumns(22));
9963 verifyFormat("#define A \\\n"
9964 " void f() { int i; } \\\n"
9965 " int j;",
9966 getLLVMStyleWithColumns(23));
9967}
9968
9969TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9970 FormatStyle MergeEmptyOnly = getLLVMStyle();
9971 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9972 verifyFormat("class C {\n"
9973 " int f() {}\n"
9974 "};",
9975 MergeEmptyOnly);
9976 verifyFormat("class C {\n"
9977 " int f() {\n"
9978 " return 42;\n"
9979 " }\n"
9980 "};",
9981 MergeEmptyOnly);
9982 verifyFormat("int f() {}", MergeEmptyOnly);
9983 verifyFormat("int f() {\n"
9984 " return 42;\n"
9985 "}",
9986 MergeEmptyOnly);
9987
9988 // Also verify behavior when BraceWrapping.AfterFunction = true
9989 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9990 MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9991 verifyFormat("int f() {}", MergeEmptyOnly);
9992 verifyFormat("class C {\n"
9993 " int f() {}\n"
9994 "};",
9995 MergeEmptyOnly);
9996}
9997
9998TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9999 FormatStyle MergeInlineOnly = getLLVMStyle();
10000 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
10001 verifyFormat("class C {\n"
10002 " int f() { return 42; }\n"
10003 "};",
10004 MergeInlineOnly);
10005 verifyFormat("int f() {\n"
10006 " return 42;\n"
10007 "}",
10008 MergeInlineOnly);
10009
10010 // SFS_Inline implies SFS_Empty
10011 verifyFormat("class C {\n"
10012 " int f() {}\n"
10013 "};",
10014 MergeInlineOnly);
10015 verifyFormat("int f() {}", MergeInlineOnly);
10016
10017 // Also verify behavior when BraceWrapping.AfterFunction = true
10018 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
10019 MergeInlineOnly.BraceWrapping.AfterFunction = true;
10020 verifyFormat("class C {\n"
10021 " int f() { return 42; }\n"
10022 "};",
10023 MergeInlineOnly);
10024 verifyFormat("int f()\n"
10025 "{\n"
10026 " return 42;\n"
10027 "}",
10028 MergeInlineOnly);
10029
10030 // SFS_Inline implies SFS_Empty
10031 verifyFormat("int f() {}", MergeInlineOnly);
10032 verifyFormat("class C {\n"
10033 " int f() {}\n"
10034 "};",
10035 MergeInlineOnly);
10036}
10037
10038TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
10039 FormatStyle MergeInlineOnly = getLLVMStyle();
10040 MergeInlineOnly.AllowShortFunctionsOnASingleLine =
10041 FormatStyle::SFS_InlineOnly;
10042 verifyFormat("class C {\n"
10043 " int f() { return 42; }\n"
10044 "};",
10045 MergeInlineOnly);
10046 verifyFormat("int f() {\n"
10047 " return 42;\n"
10048 "}",
10049 MergeInlineOnly);
10050
10051 // SFS_InlineOnly does not imply SFS_Empty
10052 verifyFormat("class C {\n"
10053 " int f() {}\n"
10054 "};",
10055 MergeInlineOnly);
10056 verifyFormat("int f() {\n"
10057 "}",
10058 MergeInlineOnly);
10059
10060 // Also verify behavior when BraceWrapping.AfterFunction = true
10061 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
10062 MergeInlineOnly.BraceWrapping.AfterFunction = true;
10063 verifyFormat("class C {\n"
10064 " int f() { return 42; }\n"
10065 "};",
10066 MergeInlineOnly);
10067 verifyFormat("int f()\n"
10068 "{\n"
10069 " return 42;\n"
10070 "}",
10071 MergeInlineOnly);
10072
10073 // SFS_InlineOnly does not imply SFS_Empty
10074 verifyFormat("int f()\n"
10075 "{\n"
10076 "}",
10077 MergeInlineOnly);
10078 verifyFormat("class C {\n"
10079 " int f() {}\n"
10080 "};",
10081 MergeInlineOnly);
10082}
10083
10084TEST_F(FormatTest, SplitEmptyFunction) {
10085 FormatStyle Style = getLLVMStyle();
10086 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
10087 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10088 Style.BraceWrapping.AfterFunction = true;
10089 Style.BraceWrapping.SplitEmptyFunction = false;
10090 Style.ColumnLimit = 40;
10091
10092 verifyFormat("int f()\n"
10093 "{}",
10094 Style);
10095 verifyFormat("int f()\n"
10096 "{\n"
10097 " return 42;\n"
10098 "}",
10099 Style);
10100 verifyFormat("int f()\n"
10101 "{\n"
10102 " // some comment\n"
10103 "}",
10104 Style);
10105
10106 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
10107 verifyFormat("int f() {}", Style);
10108 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10109 "{}",
10110 Style);
10111 verifyFormat("int f()\n"
10112 "{\n"
10113 " return 0;\n"
10114 "}",
10115 Style);
10116
10117 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
10118 verifyFormat("class Foo {\n"
10119 " int f() {}\n"
10120 "};\n",
10121 Style);
10122 verifyFormat("class Foo {\n"
10123 " int f() { return 0; }\n"
10124 "};\n",
10125 Style);
10126 verifyFormat("class Foo {\n"
10127 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10128 " {}\n"
10129 "};\n",
10130 Style);
10131 verifyFormat("class Foo {\n"
10132 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10133 " {\n"
10134 " return 0;\n"
10135 " }\n"
10136 "};\n",
10137 Style);
10138
10139 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
10140 verifyFormat("int f() {}", Style);
10141 verifyFormat("int f() { return 0; }", Style);
10142 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10143 "{}",
10144 Style);
10145 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10146 "{\n"
10147 " return 0;\n"
10148 "}",
10149 Style);
10150}
10151TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
10152 FormatStyle Style = getLLVMStyle();
10153 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
10154 verifyFormat("#ifdef A\n"
10155 "int f() {}\n"
10156 "#else\n"
10157 "int g() {}\n"
10158 "#endif",
10159 Style);
10160}
10161
10162TEST_F(FormatTest, SplitEmptyClass) {
10163 FormatStyle Style = getLLVMStyle();
10164 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10165 Style.BraceWrapping.AfterClass = true;
10166 Style.BraceWrapping.SplitEmptyRecord = false;
10167
10168 verifyFormat("class Foo\n"
10169 "{};",
10170 Style);
10171 verifyFormat("/* something */ class Foo\n"
10172 "{};",
10173 Style);
10174 verifyFormat("template <typename X> class Foo\n"
10175 "{};",
10176 Style);
10177 verifyFormat("class Foo\n"
10178 "{\n"
10179 " Foo();\n"
10180 "};",
10181 Style);
10182 verifyFormat("typedef class Foo\n"
10183 "{\n"
10184 "} Foo_t;",
10185 Style);
10186
10187 Style.BraceWrapping.SplitEmptyRecord = true;
10188 Style.BraceWrapping.AfterStruct = true;
10189 verifyFormat("class rep\n"
10190 "{\n"
10191 "};",
10192 Style);
10193 verifyFormat("struct rep\n"
10194 "{\n"
10195 "};",
10196 Style);
10197 verifyFormat("template <typename T> class rep\n"
10198 "{\n"
10199 "};",
10200 Style);
10201 verifyFormat("template <typename T> struct rep\n"
10202 "{\n"
10203 "};",
10204 Style);
10205 verifyFormat("class rep\n"
10206 "{\n"
10207 " int x;\n"
10208 "};",
10209 Style);
10210 verifyFormat("struct rep\n"
10211 "{\n"
10212 " int x;\n"
10213 "};",
10214 Style);
10215 verifyFormat("template <typename T> class rep\n"
10216 "{\n"
10217 " int x;\n"
10218 "};",
10219 Style);
10220 verifyFormat("template <typename T> struct rep\n"
10221 "{\n"
10222 " int x;\n"
10223 "};",
10224 Style);
10225 verifyFormat("template <typename T> class rep // Foo\n"
10226 "{\n"
10227 " int x;\n"
10228 "};",
10229 Style);
10230 verifyFormat("template <typename T> struct rep // Bar\n"
10231 "{\n"
10232 " int x;\n"
10233 "};",
10234 Style);
10235
10236 verifyFormat("template <typename T> class rep<T>\n"
10237 "{\n"
10238 " int x;\n"
10239 "};",
10240 Style);
10241
10242 verifyFormat("template <typename T> class rep<std::complex<T>>\n"
10243 "{\n"
10244 " int x;\n"
10245 "};",
10246 Style);
10247 verifyFormat("template <typename T> class rep<std::complex<T>>\n"
10248 "{\n"
10249 "};",
10250 Style);
10251
10252 verifyFormat("#include \"stdint.h\"\n"
10253 "namespace rep {}",
10254 Style);
10255 verifyFormat("#include <stdint.h>\n"
10256 "namespace rep {}",
10257 Style);
10258 verifyFormat("#include <stdint.h>\n"
10259 "namespace rep {}",
10260 "#include <stdint.h>\n"
10261 "namespace rep {\n"
10262 "\n"
10263 "\n"
10264 "}",
10265 Style);
10266}
10267
10268TEST_F(FormatTest, SplitEmptyStruct) {
10269 FormatStyle Style = getLLVMStyle();
10270 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10271 Style.BraceWrapping.AfterStruct = true;
10272 Style.BraceWrapping.SplitEmptyRecord = false;
10273
10274 verifyFormat("struct Foo\n"
10275 "{};",
10276 Style);
10277 verifyFormat("/* something */ struct Foo\n"
10278 "{};",
10279 Style);
10280 verifyFormat("template <typename X> struct Foo\n"
10281 "{};",
10282 Style);
10283 verifyFormat("struct Foo\n"
10284 "{\n"
10285 " Foo();\n"
10286 "};",
10287 Style);
10288 verifyFormat("typedef struct Foo\n"
10289 "{\n"
10290 "} Foo_t;",
10291 Style);
10292 // typedef struct Bar {} Bar_t;
10293}
10294
10295TEST_F(FormatTest, SplitEmptyUnion) {
10296 FormatStyle Style = getLLVMStyle();
10297 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10298 Style.BraceWrapping.AfterUnion = true;
10299 Style.BraceWrapping.SplitEmptyRecord = false;
10300
10301 verifyFormat("union Foo\n"
10302 "{};",
10303 Style);
10304 verifyFormat("/* something */ union Foo\n"
10305 "{};",
10306 Style);
10307 verifyFormat("union Foo\n"
10308 "{\n"
10309 " A,\n"
10310 "};",
10311 Style);
10312 verifyFormat("typedef union Foo\n"
10313 "{\n"
10314 "} Foo_t;",
10315 Style);
10316}
10317
10318TEST_F(FormatTest, SplitEmptyNamespace) {
10319 FormatStyle Style = getLLVMStyle();
10320 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10321 Style.BraceWrapping.AfterNamespace = true;
10322 Style.BraceWrapping.SplitEmptyNamespace = false;
10323
10324 verifyFormat("namespace Foo\n"
10325 "{};",
10326 Style);
10327 verifyFormat("/* something */ namespace Foo\n"
10328 "{};",
10329 Style);
10330 verifyFormat("inline namespace Foo\n"
10331 "{};",
10332 Style);
10333 verifyFormat("/* something */ inline namespace Foo\n"
10334 "{};",
10335 Style);
10336 verifyFormat("export namespace Foo\n"
10337 "{};",
10338 Style);
10339 verifyFormat("namespace Foo\n"
10340 "{\n"
10341 "void Bar();\n"
10342 "};",
10343 Style);
10344}
10345
10346TEST_F(FormatTest, NeverMergeShortRecords) {
10347 FormatStyle Style = getLLVMStyle();
10348
10349 verifyFormat("class Foo {\n"
10350 " Foo();\n"
10351 "};",
10352 Style);
10353 verifyFormat("typedef class Foo {\n"
10354 " Foo();\n"
10355 "} Foo_t;",
10356 Style);
10357 verifyFormat("struct Foo {\n"
10358 " Foo();\n"
10359 "};",
10360 Style);
10361 verifyFormat("typedef struct Foo {\n"
10362 " Foo();\n"
10363 "} Foo_t;",
10364 Style);
10365 verifyFormat("union Foo {\n"
10366 " A,\n"
10367 "};",
10368 Style);
10369 verifyFormat("typedef union Foo {\n"
10370 " A,\n"
10371 "} Foo_t;",
10372 Style);
10373 verifyFormat("namespace Foo {\n"
10374 "void Bar();\n"
10375 "};",
10376 Style);
10377
10378 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10379 Style.BraceWrapping.AfterClass = true;
10380 Style.BraceWrapping.AfterStruct = true;
10381 Style.BraceWrapping.AfterUnion = true;
10382 Style.BraceWrapping.AfterNamespace = true;
10383 verifyFormat("class Foo\n"
10384 "{\n"
10385 " Foo();\n"
10386 "};",
10387 Style);
10388 verifyFormat("typedef class Foo\n"
10389 "{\n"
10390 " Foo();\n"
10391 "} Foo_t;",
10392 Style);
10393 verifyFormat("struct Foo\n"
10394 "{\n"
10395 " Foo();\n"
10396 "};",
10397 Style);
10398 verifyFormat("typedef struct Foo\n"
10399 "{\n"
10400 " Foo();\n"
10401 "} Foo_t;",
10402 Style);
10403 verifyFormat("union Foo\n"
10404 "{\n"
10405 " A,\n"
10406 "};",
10407 Style);
10408 verifyFormat("typedef union Foo\n"
10409 "{\n"
10410 " A,\n"
10411 "} Foo_t;",
10412 Style);
10413 verifyFormat("namespace Foo\n"
10414 "{\n"
10415 "void Bar();\n"
10416 "};",
10417 Style);
10418}
10419
10420TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
10421 // Elaborate type variable declarations.
10422 verifyFormat("struct foo a = {bar};\nint n;");
10423 verifyFormat("class foo a = {bar};\nint n;");
10424 verifyFormat("union foo a = {bar};\nint n;");
10425
10426 // Elaborate types inside function definitions.
10427 verifyFormat("struct foo f() {}\nint n;");
10428 verifyFormat("class foo f() {}\nint n;");
10429 verifyFormat("union foo f() {}\nint n;");
10430
10431 // Templates.
10432 verifyFormat("template <class X> void f() {}\nint n;");
10433 verifyFormat("template <struct X> void f() {}\nint n;");
10434 verifyFormat("template <union X> void f() {}\nint n;");
10435
10436 // Actual definitions...
10437 verifyFormat("struct {\n} n;");
10438 verifyFormat(
10439 "template <template <class T, class Y>, class Z> class X {\n} n;");
10440 verifyFormat("union Z {\n int n;\n} x;");
10441 verifyFormat("class MACRO Z {\n} n;");
10442 verifyFormat("class MACRO(X) Z {\n} n;");
10443 verifyFormat("class __attribute__(X) Z {\n} n;");
10444 verifyFormat("class __declspec(X) Z {\n} n;");
10445 verifyFormat("class A##B##C {\n} n;");
10446 verifyFormat("class alignas(16) Z {\n} n;");
10447 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
10448 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
10449
10450 // Redefinition from nested context:
10451 verifyFormat("class A::B::C {\n} n;");
10452
10453 // Template definitions.
10454 verifyFormat(
10455 "template <typename F>\n"
10456 "Matcher(const Matcher<F> &Other,\n"
10457 " typename enable_if_c<is_base_of<F, T>::value &&\n"
10458 " !is_same<F, T>::value>::type * = 0)\n"
10459 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
10460
10461 // FIXME: This is still incorrectly handled at the formatter side.
10462 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
10463 verifyFormat("int i = SomeFunction(a<b, a> b);");
10464
10465 // FIXME:
10466 // This now gets parsed incorrectly as class definition.
10467 // verifyFormat("class A<int> f() {\n}\nint n;");
10468
10469 // Elaborate types where incorrectly parsing the structural element would
10470 // break the indent.
10471 verifyFormat("if (true)\n"
10472 " class X x;\n"
10473 "else\n"
10474 " f();\n");
10475
10476 // This is simply incomplete. Formatting is not important, but must not crash.
10477 verifyFormat("class A:");
10478}
10479
10480TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10481 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n",
10482 format("#error Leave all white!!!!! space* alone!\n"));
10483 EXPECT_EQ(
10484 "#warning Leave all white!!!!! space* alone!\n",
10485 format("#warning Leave all white!!!!! space* alone!\n"));
10486 EXPECT_EQ("#error 1", format(" # error 1"));
10487 EXPECT_EQ("#warning 1", format(" # warning 1"));
10488}
10489
10490TEST_F(FormatTest, FormatHashIfExpressions) {
10491 verifyFormat("#if AAAA && BBBB");
10492 verifyFormat("#if (AAAA && BBBB)");
10493 verifyFormat("#elif (AAAA && BBBB)");
10494 // FIXME: Come up with a better indentation for #elif.
10495 verifyFormat(
10496 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
10497 " defined(BBBBBBBB)\n"
10498 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
10499 " defined(BBBBBBBB)\n"
10500 "#endif",
10501 getLLVMStyleWithColumns(65));
10502}
10503
10504TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10505 FormatStyle AllowsMergedIf = getGoogleStyle();
10506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10507 FormatStyle::SIS_WithoutElse;
10508 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10509 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10510 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
10511 EXPECT_EQ("if (true) return 42;",
10512 format("if (true)\nreturn 42;", AllowsMergedIf));
10513 FormatStyle ShortMergedIf = AllowsMergedIf;
10514 ShortMergedIf.ColumnLimit = 25;
10515 verifyFormat("#define A \\\n"
10516 " if (true) return 42;",
10517 ShortMergedIf);
10518 verifyFormat("#define A \\\n"
10519 " f(); \\\n"
10520 " if (true)\n"
10521 "#define B",
10522 ShortMergedIf);
10523 verifyFormat("#define A \\\n"
10524 " f(); \\\n"
10525 " if (true)\n"
10526 "g();",
10527 ShortMergedIf);
10528 verifyFormat("{\n"
10529 "#ifdef A\n"
10530 " // Comment\n"
10531 " if (true) continue;\n"
10532 "#endif\n"
10533 " // Comment\n"
10534 " if (true) continue;\n"
10535 "}",
10536 ShortMergedIf);
10537 ShortMergedIf.ColumnLimit = 33;
10538 verifyFormat("#define A \\\n"
10539 " if constexpr (true) return 42;",
10540 ShortMergedIf);
10541 verifyFormat("#define A \\\n"
10542 " if CONSTEXPR (true) return 42;",
10543 ShortMergedIf);
10544 ShortMergedIf.ColumnLimit = 29;
10545 verifyFormat("#define A \\\n"
10546 " if (aaaaaaaaaa) return 1; \\\n"
10547 " return 2;",
10548 ShortMergedIf);
10549 ShortMergedIf.ColumnLimit = 28;
10550 verifyFormat("#define A \\\n"
10551 " if (aaaaaaaaaa) \\\n"
10552 " return 1; \\\n"
10553 " return 2;",
10554 ShortMergedIf);
10555 verifyFormat("#define A \\\n"
10556 " if constexpr (aaaaaaa) \\\n"
10557 " return 1; \\\n"
10558 " return 2;",
10559 ShortMergedIf);
10560 verifyFormat("#define A \\\n"
10561 " if CONSTEXPR (aaaaaaa) \\\n"
10562 " return 1; \\\n"
10563 " return 2;",
10564 ShortMergedIf);
10565}
10566
10567TEST_F(FormatTest, FormatStarDependingOnContext) {
10568 verifyFormat("void f(int *a);");
10569 verifyFormat("void f() { f(fint * b); }");
10570 verifyFormat("class A {\n void f(int *a);\n};");
10571 verifyFormat("class A {\n int *a;\n};");
10572 verifyFormat("namespace a {\n"
10573 "namespace b {\n"
10574 "class A {\n"
10575 " void f() {}\n"
10576 " int *a;\n"
10577 "};\n"
10578 "} // namespace b\n"
10579 "} // namespace a");
10580}
10581
10582TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10583 verifyFormat("while");
10584 verifyFormat("operator");
10585}
10586
10587TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10588 // This code would be painfully slow to format if we didn't skip it.
10589 std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
10590 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10591 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10592 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10593 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10594 "A(1, 1)\n"
10595 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10596 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10597 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10598 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10599 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10600 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10601 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10602 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10603 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10604 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10605 // Deeply nested part is untouched, rest is formatted.
10606 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10607 format(std::string("int i;\n") + Code + "int j;\n",
10608 getLLVMStyle(), SC_ExpectIncomplete));
10609}
10610
10611//===----------------------------------------------------------------------===//
10612// Objective-C tests.
10613//===----------------------------------------------------------------------===//
10614
10615TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10616 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10617 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10618 format("-(NSUInteger)indexOfObject:(id)anObject;"));
10619 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10620 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10621 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10622 format("-(NSInteger)Method3:(id)anObject;"));
10623 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10624 format("-(NSInteger)Method4:(id)anObject;"));
10625 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10626 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10627 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10628 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10629 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10630 "forAllCells:(BOOL)flag;",
10631 format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10632 "forAllCells:(BOOL)flag;"));
10633
10634 // Very long objectiveC method declaration.
10635 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10636 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10637 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10638 " inRange:(NSRange)range\n"
10639 " outRange:(NSRange)out_range\n"
10640 " outRange1:(NSRange)out_range1\n"
10641 " outRange2:(NSRange)out_range2\n"
10642 " outRange3:(NSRange)out_range3\n"
10643 " outRange4:(NSRange)out_range4\n"
10644 " outRange5:(NSRange)out_range5\n"
10645 " outRange6:(NSRange)out_range6\n"
10646 " outRange7:(NSRange)out_range7\n"
10647 " outRange8:(NSRange)out_range8\n"
10648 " outRange9:(NSRange)out_range9;");
10649
10650 // When the function name has to be wrapped.
10651 FormatStyle Style = getLLVMStyle();
10652 // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10653 // and always indents instead.
10654 Style.IndentWrappedFunctionNames = false;
10655 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10656 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10657 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10658 "}",
10659 Style);
10660 Style.IndentWrappedFunctionNames = true;
10661 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10662 " veryLooooooooooongName:(NSString)cccccccccccccc\n"
10663 " anotherName:(NSString)dddddddddddddd {\n"
10664 "}",
10665 Style);
10666
10667 verifyFormat("- (int)sum:(vector<int>)numbers;");
10668 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10669 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10670 // protocol lists (but not for template classes):
10671 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10672
10673 verifyFormat("- (int (*)())foo:(int (*)())f;");
10674 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10675
10676 // If there's no return type (very rare in practice!), LLVM and Google style
10677 // agree.
10678 verifyFormat("- foo;");
10679 verifyFormat("- foo:(int)f;");
10680 verifyGoogleFormat("- foo:(int)foo;");
10681}
10682
10683TEST_F(FormatTest, BreaksStringLiterals) {
10684 EXPECT_EQ("\"some text \"\n"
10685 "\"other\";",
10686 format("\"some text other\";", getLLVMStyleWithColumns(12)));
10687 EXPECT_EQ("\"some text \"\n"
10688 "\"other\";",
10689 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10690 EXPECT_EQ(
10691 "#define A \\\n"
10692 " \"some \" \\\n"
10693 " \"text \" \\\n"
10694 " \"other\";",
10695 format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10696 EXPECT_EQ(
10697 "#define A \\\n"
10698 " \"so \" \\\n"
10699 " \"text \" \\\n"
10700 " \"other\";",
10701 format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10702
10703 EXPECT_EQ("\"some text\"",
10704 format("\"some text\"", getLLVMStyleWithColumns(1)));
10705 EXPECT_EQ("\"some text\"",
10706 format("\"some text\"", getLLVMStyleWithColumns(11)));
10707 EXPECT_EQ("\"some \"\n"
10708 "\"text\"",
10709 format("\"some text\"", getLLVMStyleWithColumns(10)));
10710 EXPECT_EQ("\"some \"\n"
10711 "\"text\"",
10712 format("\"some text\"", getLLVMStyleWithColumns(7)));
10713 EXPECT_EQ("\"some\"\n"
10714 "\" tex\"\n"
10715 "\"t\"",
10716 format("\"some text\"", getLLVMStyleWithColumns(6)));
10717 EXPECT_EQ("\"some\"\n"
10718 "\" tex\"\n"
10719 "\" and\"",
10720 format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10721 EXPECT_EQ("\"some\"\n"
10722 "\"/tex\"\n"
10723 "\"/and\"",
10724 format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10725
10726 EXPECT_EQ("variable =\n"
10727 " \"long string \"\n"
10728 " \"literal\";",
10729 format("variable = \"long string literal\";",
10730 getLLVMStyleWithColumns(20)));
10731
10732 EXPECT_EQ("variable = f(\n"
10733 " \"long string \"\n"
10734 " \"literal\",\n"
10735 " short,\n"
10736 " loooooooooooooooooooong);",
10737 format("variable = f(\"long string literal\", short, "
10738 "loooooooooooooooooooong);",
10739 getLLVMStyleWithColumns(20)));
10740
10741 EXPECT_EQ(
10742 "f(g(\"long string \"\n"
10743 " \"literal\"),\n"
10744 " b);",
10745 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10746 EXPECT_EQ("f(g(\"long string \"\n"
10747 " \"literal\",\n"
10748 " a),\n"
10749 " b);",
10750 format("f(g(\"long string literal\", a), b);",
10751 getLLVMStyleWithColumns(20)));
10752 EXPECT_EQ(
10753 "f(\"one two\".split(\n"
10754 " variable));",
10755 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10756 EXPECT_EQ("f(\"one two three four five six \"\n"
10757 " \"seven\".split(\n"
10758 " really_looooong_variable));",
10759 format("f(\"one two three four five six seven\"."
10760 "split(really_looooong_variable));",
10761 getLLVMStyleWithColumns(33)));
10762
10763 EXPECT_EQ("f(\"some \"\n"
10764 " \"text\",\n"
10765 " other);",
10766 format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10767
10768 // Only break as a last resort.
10769 verifyFormat(
10770 "aaaaaaaaaaaaaaaaaaaa(\n"
10771 " aaaaaaaaaaaaaaaaaaaa,\n"
10772 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10773
10774 EXPECT_EQ("\"splitmea\"\n"
10775 "\"trandomp\"\n"
10776 "\"oint\"",
10777 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10778
10779 EXPECT_EQ("\"split/\"\n"
10780 "\"pathat/\"\n"
10781 "\"slashes\"",
10782 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10783
10784 EXPECT_EQ("\"split/\"\n"
10785 "\"pathat/\"\n"
10786 "\"slashes\"",
10787 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10788 EXPECT_EQ("\"split at \"\n"
10789 "\"spaces/at/\"\n"
10790 "\"slashes.at.any$\"\n"
10791 "\"non-alphanumeric%\"\n"
10792 "\"1111111111characte\"\n"
10793 "\"rs\"",
10794 format("\"split at "
10795 "spaces/at/"
10796 "slashes.at."
10797 "any$non-"
10798 "alphanumeric%"
10799 "1111111111characte"
10800 "rs\"",
10801 getLLVMStyleWithColumns(20)));
10802
10803 // Verify that splitting the strings understands
10804 // Style::AlwaysBreakBeforeMultilineStrings.
10805 EXPECT_EQ("aaaaaaaaaaaa(\n"
10806 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10807 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10808 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10809 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10810 "aaaaaaaaaaaaaaaaaaaaaa\");",
10811 getGoogleStyle()));
10812 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10813 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10814 format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10815 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10816 "aaaaaaaaaaaaaaaaaaaaaa\";",
10817 getGoogleStyle()));
10818 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10819 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10820 format("llvm::outs() << "
10821 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10822 "aaaaaaaaaaaaaaaaaaa\";"));
10823 EXPECT_EQ("ffff(\n"
10824 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10825 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10826 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10827 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10828 getGoogleStyle()));
10829
10830 FormatStyle Style = getLLVMStyleWithColumns(12);
10831 Style.BreakStringLiterals = false;
10832 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10833
10834 FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10835 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10836 EXPECT_EQ("#define A \\\n"
10837 " \"some \" \\\n"
10838 " \"text \" \\\n"
10839 " \"other\";",
10840 format("#define A \"some text other\";", AlignLeft));
10841}
10842
10843TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10844 EXPECT_EQ("C a = \"some more \"\n"
10845 " \"text\";",
10846 format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10847}
10848
10849TEST_F(FormatTest, FullyRemoveEmptyLines) {
10850 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10851 NoEmptyLines.MaxEmptyLinesToKeep = 0;
10852 EXPECT_EQ("int i = a(b());",
10853 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10854}
10855
10856TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10857 EXPECT_EQ(
10858 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10859 "(\n"
10860 " \"x\t\");",
10861 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10862 "aaaaaaa("
10863 "\"x\t\");"));
10864}
10865
10866TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10867 EXPECT_EQ(
10868 "u8\"utf8 string \"\n"
10869 "u8\"literal\";",
10870 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10871 EXPECT_EQ(
10872 "u\"utf16 string \"\n"
10873 "u\"literal\";",
10874 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10875 EXPECT_EQ(
10876 "U\"utf32 string \"\n"
10877 "U\"literal\";",
10878 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10879 EXPECT_EQ("L\"wide string \"\n"
10880 "L\"literal\";",
10881 format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10882 EXPECT_EQ("@\"NSString \"\n"
10883 "@\"literal\";",
10884 format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10885 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10886
10887 // This input makes clang-format try to split the incomplete unicode escape
10888 // sequence, which used to lead to a crasher.
10889 verifyNoCrash(
10890 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10891 getLLVMStyleWithColumns(60));
10892}
10893
10894TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10895 FormatStyle Style = getGoogleStyleWithColumns(15);
10896 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10897 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10898 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10899 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10900 EXPECT_EQ("u8R\"x(raw literal)x\";",
10901 format("u8R\"x(raw literal)x\";", Style));
10902}
10903
10904TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10905 FormatStyle Style = getLLVMStyleWithColumns(20);
10906 EXPECT_EQ(
10907 "_T(\"aaaaaaaaaaaaaa\")\n"
10908 "_T(\"aaaaaaaaaaaaaa\")\n"
10909 "_T(\"aaaaaaaaaaaa\")",
10910 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10911 EXPECT_EQ("f(x,\n"
10912 " _T(\"aaaaaaaaaaaa\")\n"
10913 " _T(\"aaa\"),\n"
10914 " z);",
10915 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10916
10917 // FIXME: Handle embedded spaces in one iteration.
10918 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10919 // "_T(\"aaaaaaaaaaaaa\")\n"
10920 // "_T(\"aaaaaaaaaaaaa\")\n"
10921 // "_T(\"a\")",
10922 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10923 // getLLVMStyleWithColumns(20)));
10924 EXPECT_EQ(
10925 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10926 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10927 EXPECT_EQ("f(\n"
10928 "#if !TEST\n"
10929 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10930 "#endif\n"
10931 ");",
10932 format("f(\n"
10933 "#if !TEST\n"
10934 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10935 "#endif\n"
10936 ");"));
10937 EXPECT_EQ("f(\n"
10938 "\n"
10939 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10940 format("f(\n"
10941 "\n"
10942 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10943}
10944
10945TEST_F(FormatTest, BreaksStringLiteralOperands) {
10946 // In a function call with two operands, the second can be broken with no line
10947 // break before it.
10948 EXPECT_EQ(
10949 "func(a, \"long long \"\n"
10950 " \"long long\");",
10951 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10952 // In a function call with three operands, the second must be broken with a
10953 // line break before it.
10954 EXPECT_EQ("func(a,\n"
10955 " \"long long long \"\n"
10956 " \"long\",\n"
10957 " c);",
10958 format("func(a, \"long long long long\", c);",
10959 getLLVMStyleWithColumns(24)));
10960 // In a function call with three operands, the third must be broken with a
10961 // line break before it.
10962 EXPECT_EQ("func(a, b,\n"
10963 " \"long long long \"\n"
10964 " \"long\");",
10965 format("func(a, b, \"long long long long\");",
10966 getLLVMStyleWithColumns(24)));
10967 // In a function call with three operands, both the second and the third must
10968 // be broken with a line break before them.
10969 EXPECT_EQ("func(a,\n"
10970 " \"long long long \"\n"
10971 " \"long\",\n"
10972 " \"long long long \"\n"
10973 " \"long\");",
10974 format("func(a, \"long long long long\", \"long long long long\");",
10975 getLLVMStyleWithColumns(24)));
10976 // In a chain of << with two operands, the second can be broken with no line
10977 // break before it.
10978 EXPECT_EQ("a << \"line line \"\n"
10979 " \"line\";",
10980 format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10981 // In a chain of << with three operands, the second can be broken with no line
10982 // break before it.
10983 EXPECT_EQ(
10984 "abcde << \"line \"\n"
10985 " \"line line\"\n"
10986 " << c;",
10987 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10988 // In a chain of << with three operands, the third must be broken with a line
10989 // break before it.
10990 EXPECT_EQ(
10991 "a << b\n"
10992 " << \"line line \"\n"
10993 " \"line\";",
10994 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10995 // In a chain of << with three operands, the second can be broken with no line
10996 // break before it and the third must be broken with a line break before it.
10997 EXPECT_EQ("abcd << \"line line \"\n"
10998 " \"line\"\n"
10999 " << \"line line \"\n"
11000 " \"line\";",
11001 format("abcd << \"line line line\" << \"line line line\";",
11002 getLLVMStyleWithColumns(20)));
11003 // In a chain of binary operators with two operands, the second can be broken
11004 // with no line break before it.
11005 EXPECT_EQ(
11006 "abcd + \"line line \"\n"
11007 " \"line line\";",
11008 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
11009 // In a chain of binary operators with three operands, the second must be
11010 // broken with a line break before it.
11011 EXPECT_EQ("abcd +\n"
11012 " \"line line \"\n"
11013 " \"line line\" +\n"
11014 " e;",
11015 format("abcd + \"line line line line\" + e;",
11016 getLLVMStyleWithColumns(20)));
11017 // In a function call with two operands, with AlignAfterOpenBracket enabled,
11018 // the first must be broken with a line break before it.
11019 FormatStyle Style = getLLVMStyleWithColumns(25);
11020 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
11021 EXPECT_EQ("someFunction(\n"
11022 " \"long long long \"\n"
11023 " \"long\",\n"
11024 " a);",
11025 format("someFunction(\"long long long long\", a);", Style));
11026}
11027
11028TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
11029 EXPECT_EQ(
11030 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
11033 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11035 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
11036}
11037
11038TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
11039 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
11040 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));
11041 EXPECT_EQ("fffffffffff(g(R\"x(\n"
11042 "multiline raw string literal xxxxxxxxxxxxxx\n"
11043 ")x\",\n"
11044 " a),\n"
11045 " b);",
11046 format("fffffffffff(g(R\"x(\n"
11047 "multiline raw string literal xxxxxxxxxxxxxx\n"
11048 ")x\", a), b);",
11049 getGoogleStyleWithColumns(20)));
11050 EXPECT_EQ("fffffffffff(\n"
11051 " g(R\"x(qqq\n"
11052 "multiline raw string literal xxxxxxxxxxxxxx\n"
11053 ")x\",\n"
11054 " a),\n"
11055 " b);",
11056 format("fffffffffff(g(R\"x(qqq\n"
11057 "multiline raw string literal xxxxxxxxxxxxxx\n"
11058 ")x\", a), b);",
11059 getGoogleStyleWithColumns(20)));
11060
11061 EXPECT_EQ("fffffffffff(R\"x(\n"
11062 "multiline raw string literal xxxxxxxxxxxxxx\n"
11063 ")x\");",
11064 format("fffffffffff(R\"x(\n"
11065 "multiline raw string literal xxxxxxxxxxxxxx\n"
11066 ")x\");",
11067 getGoogleStyleWithColumns(20)));
11068 EXPECT_EQ("fffffffffff(R\"x(\n"
11069 "multiline raw string literal xxxxxxxxxxxxxx\n"
11070 ")x\" + bbbbbb);",
11071 format("fffffffffff(R\"x(\n"
11072 "multiline raw string literal xxxxxxxxxxxxxx\n"
11073 ")x\" + bbbbbb);",
11074 getGoogleStyleWithColumns(20)));
11075 EXPECT_EQ("fffffffffff(\n"
11076 " R\"x(\n"
11077 "multiline raw string literal xxxxxxxxxxxxxx\n"
11078 ")x\" +\n"
11079 " bbbbbb);",
11080 format("fffffffffff(\n"
11081 " R\"x(\n"
11082 "multiline raw string literal xxxxxxxxxxxxxx\n"
11083 ")x\" + bbbbbb);",
11084 getGoogleStyleWithColumns(20)));
11085 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
11086 format("fffffffffff(\n"
11087 " R\"(single line raw string)\" + bbbbbb);"));
11088}
11089
11090TEST_F(FormatTest, SkipsUnknownStringLiterals) {
11091 verifyFormat("string a = \"unterminated;");
11092 EXPECT_EQ("function(\"unterminated,\n"
11093 " OtherParameter);",
11094 format("function( \"unterminated,\n"
11095 " OtherParameter);"));
11096}
11097
11098TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
11099 FormatStyle Style = getLLVMStyle();
11100 Style.Standard = FormatStyle::LS_Cpp03;
11101 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
11102 format("#define x(_a) printf(\"foo\"_a);", Style));
11103}
11104
11105TEST_F(FormatTest, CppLexVersion) {
11106 FormatStyle Style = getLLVMStyle();
11107 // Formatting of x * y differs if x is a type.
11108 verifyFormat("void foo() { MACRO(a * b); }", Style);
11109 verifyFormat("void foo() { MACRO(int *b); }", Style);
11110
11111 // LLVM style uses latest lexer.
11112 verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
11113 Style.Standard = FormatStyle::LS_Cpp17;
11114 // But in c++17, char8_t isn't a keyword.
11115 verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
11116}
11117
11118TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
11119
11120TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
11121 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
11122 " \"ddeeefff\");",
11123 format("someFunction(\"aaabbbcccdddeeefff\");",
11124 getLLVMStyleWithColumns(25)));
11125 EXPECT_EQ("someFunction1234567890(\n"
11126 " \"aaabbbcccdddeeefff\");",
11127 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11128 getLLVMStyleWithColumns(26)));
11129 EXPECT_EQ("someFunction1234567890(\n"
11130 " \"aaabbbcccdddeeeff\"\n"
11131 " \"f\");",
11132 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11133 getLLVMStyleWithColumns(25)));
11134 EXPECT_EQ("someFunction1234567890(\n"
11135 " \"aaabbbcccdddeeeff\"\n"
11136 " \"f\");",
11137 format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11138 getLLVMStyleWithColumns(24)));
11139 EXPECT_EQ("someFunction(\n"
11140 " \"aaabbbcc ddde \"\n"
11141 " \"efff\");",
11142 format("someFunction(\"aaabbbcc ddde efff\");",
11143 getLLVMStyleWithColumns(25)));
11144 EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
11145 " \"ddeeefff\");",
11146 format("someFunction(\"aaabbbccc ddeeefff\");",
11147 getLLVMStyleWithColumns(25)));
11148 EXPECT_EQ("someFunction1234567890(\n"
11149 " \"aaabb \"\n"
11150 " \"cccdddeeefff\");",
11151 format("someFunction1234567890(\"aaabb cccdddeeefff\");",
11152 getLLVMStyleWithColumns(25)));
11153 EXPECT_EQ("#define A \\\n"
11154 " string s = \\\n"
11155 " \"123456789\" \\\n"
11156 " \"0\"; \\\n"
11157 " int i;",
11158 format("#define A string s = \"1234567890\"; int i;",
11159 getLLVMStyleWithColumns(20)));
11160 EXPECT_EQ("someFunction(\n"
11161 " \"aaabbbcc \"\n"
11162 " \"dddeeefff\");",
11163 format("someFunction(\"aaabbbcc dddeeefff\");",
11164 getLLVMStyleWithColumns(25)));
11165}
11166
11167TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
11168 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
11169 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
11170 EXPECT_EQ("\"test\"\n"
11171 "\"\\n\"",
11172 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
11173 EXPECT_EQ("\"tes\\\\\"\n"
11174 "\"n\"",
11175 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
11176 EXPECT_EQ("\"\\\\\\\\\"\n"
11177 "\"\\n\"",
11178 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
11179 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
11180 EXPECT_EQ("\"\\uff01\"\n"
11181 "\"test\"",
11182 format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
11183 EXPECT_EQ("\"\\Uff01ff02\"",
11184 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
11185 EXPECT_EQ("\"\\x000000000001\"\n"
11186 "\"next\"",
11187 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
11188 EXPECT_EQ("\"\\x000000000001next\"",
11189 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
11190 EXPECT_EQ("\"\\x000000000001\"",
11191 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
11192 EXPECT_EQ("\"test\"\n"
11193 "\"\\000000\"\n"
11194 "\"000001\"",
11195 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
11196 EXPECT_EQ("\"test\\000\"\n"
11197 "\"00000000\"\n"
11198 "\"1\"",
11199 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
11200}
11201
11202TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
11203 verifyFormat("void f() {\n"
11204 " return g() {}\n"
11205 " void h() {}");
11206 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
11207 "g();\n"
11208 "}");
11209}
11210
11211TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
11212 verifyFormat(
11213 "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
11214}
11215
11216TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
11217 verifyFormat("class X {\n"
11218 " void f() {\n"
11219 " }\n"
11220 "};",
11221 getLLVMStyleWithColumns(12));
11222}
11223
11224TEST_F(FormatTest, ConfigurableIndentWidth) {
11225 FormatStyle EightIndent = getLLVMStyleWithColumns(18);
11226 EightIndent.IndentWidth = 8;
11227 EightIndent.ContinuationIndentWidth = 8;
11228 verifyFormat("void f() {\n"
11229 " someFunction();\n"
11230 " if (true) {\n"
11231 " f();\n"
11232 " }\n"
11233 "}",
11234 EightIndent);
11235 verifyFormat("class X {\n"
11236 " void f() {\n"
11237 " }\n"
11238 "};",
11239 EightIndent);
11240 verifyFormat("int x[] = {\n"
11241 " call(),\n"
11242 " call()};",
11243 EightIndent);
11244}
11245
11246TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
11247 verifyFormat("double\n"
11248 "f();",
11249 getLLVMStyleWithColumns(8));
11250}
11251
11252TEST_F(FormatTest, ConfigurableUseOfTab) {
11253 FormatStyle Tab = getLLVMStyleWithColumns(42);
11254 Tab.IndentWidth = 8;
11255 Tab.UseTab = FormatStyle::UT_Always;
11256 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11257
11258 EXPECT_EQ("if (aaaaaaaa && // q\n"
11259 " bb)\t\t// w\n"
11260 "\t;",
11261 format("if (aaaaaaaa &&// q\n"
11262 "bb)// w\n"
11263 ";",
11264 Tab));
11265 EXPECT_EQ("if (aaa && bbb) // w\n"
11266 "\t;",
11267 format("if(aaa&&bbb)// w\n"
11268 ";",
11269 Tab));
11270
11271 verifyFormat("class X {\n"
11272 "\tvoid f() {\n"
11273 "\t\tsomeFunction(parameter1,\n"
11274 "\t\t\t parameter2);\n"
11275 "\t}\n"
11276 "};",
11277 Tab);
11278 verifyFormat("#define A \\\n"
11279 "\tvoid f() { \\\n"
11280 "\t\tsomeFunction( \\\n"
11281 "\t\t parameter1, \\\n"
11282 "\t\t parameter2); \\\n"
11283 "\t}",
11284 Tab);
11285 verifyFormat("int a;\t // x\n"
11286 "int bbbbbbbb; // x\n",
11287 Tab);
11288
11289 Tab.TabWidth = 4;
11290 Tab.IndentWidth = 8;
11291 verifyFormat("class TabWidth4Indent8 {\n"
11292 "\t\tvoid f() {\n"
11293 "\t\t\t\tsomeFunction(parameter1,\n"
11294 "\t\t\t\t\t\t\t parameter2);\n"
11295 "\t\t}\n"
11296 "};",
11297 Tab);
11298
11299 Tab.TabWidth = 4;
11300 Tab.IndentWidth = 4;
11301 verifyFormat("class TabWidth4Indent4 {\n"
11302 "\tvoid f() {\n"
11303 "\t\tsomeFunction(parameter1,\n"
11304 "\t\t\t\t\t parameter2);\n"
11305 "\t}\n"
11306 "};",
11307 Tab);
11308
11309 Tab.TabWidth = 8;
11310 Tab.IndentWidth = 4;
11311 verifyFormat("class TabWidth8Indent4 {\n"
11312 " void f() {\n"
11313 "\tsomeFunction(parameter1,\n"
11314 "\t\t parameter2);\n"
11315 " }\n"
11316 "};",
11317 Tab);
11318
11319 Tab.TabWidth = 8;
11320 Tab.IndentWidth = 8;
11321 EXPECT_EQ("/*\n"
11322 "\t a\t\tcomment\n"
11323 "\t in multiple lines\n"
11324 " */",
11325 format(" /*\t \t \n"
11326 " \t \t a\t\tcomment\t \t\n"
11327 " \t \t in multiple lines\t\n"
11328 " \t */",
11329 Tab));
11330
11331 Tab.UseTab = FormatStyle::UT_ForIndentation;
11332 verifyFormat("{\n"
11333 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11334 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11335 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11336 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11337 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11338 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11339 "};",
11340 Tab);
11341 verifyFormat("enum AA {\n"
11342 "\ta1, // Force multiple lines\n"
11343 "\ta2,\n"
11344 "\ta3\n"
11345 "};",
11346 Tab);
11347 EXPECT_EQ("if (aaaaaaaa && // q\n"
11348 " bb) // w\n"
11349 "\t;",
11350 format("if (aaaaaaaa &&// q\n"
11351 "bb)// w\n"
11352 ";",
11353 Tab));
11354 verifyFormat("class X {\n"
11355 "\tvoid f() {\n"
11356 "\t\tsomeFunction(parameter1,\n"
11357 "\t\t parameter2);\n"
11358 "\t}\n"
11359 "};",
11360 Tab);
11361 verifyFormat("{\n"
11362 "\tQ(\n"
11363 "\t {\n"
11364 "\t\t int a;\n"
11365 "\t\t someFunction(aaaaaaaa,\n"
11366 "\t\t bbbbbbb);\n"
11367 "\t },\n"
11368 "\t p);\n"
11369 "}",
11370 Tab);
11371 EXPECT_EQ("{\n"
11372 "\t/* aaaa\n"
11373 "\t bbbb */\n"
11374 "}",
11375 format("{\n"
11376 "/* aaaa\n"
11377 " bbbb */\n"
11378 "}",
11379 Tab));
11380 EXPECT_EQ("{\n"
11381 "\t/*\n"
11382 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11383 "\t bbbbbbbbbbbbb\n"
11384 "\t*/\n"
11385 "}",
11386 format("{\n"
11387 "/*\n"
11388 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11389 "*/\n"
11390 "}",
11391 Tab));
11392 EXPECT_EQ("{\n"
11393 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11394 "\t// bbbbbbbbbbbbb\n"
11395 "}",
11396 format("{\n"
11397 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11398 "}",
11399 Tab));
11400 EXPECT_EQ("{\n"
11401 "\t/*\n"
11402 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11403 "\t bbbbbbbbbbbbb\n"
11404 "\t*/\n"
11405 "}",
11406 format("{\n"
11407 "\t/*\n"
11408 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11409 "\t*/\n"
11410 "}",
11411 Tab));
11412 EXPECT_EQ("{\n"
11413 "\t/*\n"
11414 "\n"
11415 "\t*/\n"
11416 "}",
11417 format("{\n"
11418 "\t/*\n"
11419 "\n"
11420 "\t*/\n"
11421 "}",
11422 Tab));
11423 EXPECT_EQ("{\n"
11424 "\t/*\n"
11425 " asdf\n"
11426 "\t*/\n"
11427 "}",
11428 format("{\n"
11429 "\t/*\n"
11430 " asdf\n"
11431 "\t*/\n"
11432 "}",
11433 Tab));
11434
11435 Tab.UseTab = FormatStyle::UT_Never;
11436 EXPECT_EQ("/*\n"
11437 " a\t\tcomment\n"
11438 " in multiple lines\n"
11439 " */",
11440 format(" /*\t \t \n"
11441 " \t \t a\t\tcomment\t \t\n"
11442 " \t \t in multiple lines\t\n"
11443 " \t */",
11444 Tab));
11445 EXPECT_EQ("/* some\n"
11446 " comment */",
11447 format(" \t \t /* some\n"
11448 " \t \t comment */",
11449 Tab));
11450 EXPECT_EQ("int a; /* some\n"
11451 " comment */",
11452 format(" \t \t int a; /* some\n"
11453 " \t \t comment */",
11454 Tab));
11455
11456 EXPECT_EQ("int a; /* some\n"
11457 "comment */",
11458 format(" \t \t int\ta; /* some\n"
11459 " \t \t comment */",
11460 Tab));
11461 EXPECT_EQ("f(\"\t\t\"); /* some\n"
11462 " comment */",
11463 format(" \t \t f(\"\t\t\"); /* some\n"
11464 " \t \t comment */",
11465 Tab));
11466 EXPECT_EQ("{\n"
11467 " /*\n"
11468 " * Comment\n"
11469 " */\n"
11470 " int i;\n"
11471 "}",
11472 format("{\n"
11473 "\t/*\n"
11474 "\t * Comment\n"
11475 "\t */\n"
11476 "\t int i;\n"
11477 "}",
11478 Tab));
11479
11480 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11481 Tab.TabWidth = 8;
11482 Tab.IndentWidth = 8;
11483 EXPECT_EQ("if (aaaaaaaa && // q\n"
11484 " bb) // w\n"
11485 "\t;",
11486 format("if (aaaaaaaa &&// q\n"
11487 "bb)// w\n"
11488 ";",
11489 Tab));
11490 EXPECT_EQ("if (aaa && bbb) // w\n"
11491 "\t;",
11492 format("if(aaa&&bbb)// w\n"
11493 ";",
11494 Tab));
11495 verifyFormat("class X {\n"
11496 "\tvoid f() {\n"
11497 "\t\tsomeFunction(parameter1,\n"
11498 "\t\t\t parameter2);\n"
11499 "\t}\n"
11500 "};",
11501 Tab);
11502 verifyFormat("#define A \\\n"
11503 "\tvoid f() { \\\n"
11504 "\t\tsomeFunction( \\\n"
11505 "\t\t parameter1, \\\n"
11506 "\t\t parameter2); \\\n"
11507 "\t}",
11508 Tab);
11509 Tab.TabWidth = 4;
11510 Tab.IndentWidth = 8;
11511 verifyFormat("class TabWidth4Indent8 {\n"
11512 "\t\tvoid f() {\n"
11513 "\t\t\t\tsomeFunction(parameter1,\n"
11514 "\t\t\t\t\t\t\t parameter2);\n"
11515 "\t\t}\n"
11516 "};",
11517 Tab);
11518 Tab.TabWidth = 4;
11519 Tab.IndentWidth = 4;
11520 verifyFormat("class TabWidth4Indent4 {\n"
11521 "\tvoid f() {\n"
11522 "\t\tsomeFunction(parameter1,\n"
11523 "\t\t\t\t\t parameter2);\n"
11524 "\t}\n"
11525 "};",
11526 Tab);
11527 Tab.TabWidth = 8;
11528 Tab.IndentWidth = 4;
11529 verifyFormat("class TabWidth8Indent4 {\n"
11530 " void f() {\n"
11531 "\tsomeFunction(parameter1,\n"
11532 "\t\t parameter2);\n"
11533 " }\n"
11534 "};",
11535 Tab);
11536 Tab.TabWidth = 8;
11537 Tab.IndentWidth = 8;
11538 EXPECT_EQ("/*\n"
11539 "\t a\t\tcomment\n"
11540 "\t in multiple lines\n"
11541 " */",
11542 format(" /*\t \t \n"
11543 " \t \t a\t\tcomment\t \t\n"
11544 " \t \t in multiple lines\t\n"
11545 " \t */",
11546 Tab));
11547 verifyFormat("{\n"
11548 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11549 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11550 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11551 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11552 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11553 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11554 "};",
11555 Tab);
11556 verifyFormat("enum AA {\n"
11557 "\ta1, // Force multiple lines\n"
11558 "\ta2,\n"
11559 "\ta3\n"
11560 "};",
11561 Tab);
11562 EXPECT_EQ("if (aaaaaaaa && // q\n"
11563 " bb) // w\n"
11564 "\t;",
11565 format("if (aaaaaaaa &&// q\n"
11566 "bb)// w\n"
11567 ";",
11568 Tab));
11569 verifyFormat("class X {\n"
11570 "\tvoid f() {\n"
11571 "\t\tsomeFunction(parameter1,\n"
11572 "\t\t\t parameter2);\n"
11573 "\t}\n"
11574 "};",
11575 Tab);
11576 verifyFormat("{\n"
11577 "\tQ(\n"
11578 "\t {\n"
11579 "\t\t int a;\n"
11580 "\t\t someFunction(aaaaaaaa,\n"
11581 "\t\t\t\t bbbbbbb);\n"
11582 "\t },\n"
11583 "\t p);\n"
11584 "}",
11585 Tab);
11586 EXPECT_EQ("{\n"
11587 "\t/* aaaa\n"
11588 "\t bbbb */\n"
11589 "}",
11590 format("{\n"
11591 "/* aaaa\n"
11592 " bbbb */\n"
11593 "}",
11594 Tab));
11595 EXPECT_EQ("{\n"
11596 "\t/*\n"
11597 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11598 "\t bbbbbbbbbbbbb\n"
11599 "\t*/\n"
11600 "}",
11601 format("{\n"
11602 "/*\n"
11603 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11604 "*/\n"
11605 "}",
11606 Tab));
11607 EXPECT_EQ("{\n"
11608 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11609 "\t// bbbbbbbbbbbbb\n"
11610 "}",
11611 format("{\n"
11612 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11613 "}",
11614 Tab));
11615 EXPECT_EQ("{\n"
11616 "\t/*\n"
11617 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11618 "\t bbbbbbbbbbbbb\n"
11619 "\t*/\n"
11620 "}",
11621 format("{\n"
11622 "\t/*\n"
11623 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11624 "\t*/\n"
11625 "}",
11626 Tab));
11627 EXPECT_EQ("{\n"
11628 "\t/*\n"
11629 "\n"
11630 "\t*/\n"
11631 "}",
11632 format("{\n"
11633 "\t/*\n"
11634 "\n"
11635 "\t*/\n"
11636 "}",
11637 Tab));
11638 EXPECT_EQ("{\n"
11639 "\t/*\n"
11640 " asdf\n"
11641 "\t*/\n"
11642 "}",
11643 format("{\n"
11644 "\t/*\n"
11645 " asdf\n"
11646 "\t*/\n"
11647 "}",
11648 Tab));
11649 EXPECT_EQ("/* some\n"
11650 " comment */",
11651 format(" \t \t /* some\n"
11652 " \t \t comment */",
11653 Tab));
11654 EXPECT_EQ("int a; /* some\n"
11655 " comment */",
11656 format(" \t \t int a; /* some\n"
11657 " \t \t comment */",
11658 Tab));
11659 EXPECT_EQ("int a; /* some\n"
11660 "comment */",
11661 format(" \t \t int\ta; /* some\n"
11662 " \t \t comment */",
11663 Tab));
11664 EXPECT_EQ("f(\"\t\t\"); /* some\n"
11665 " comment */",
11666 format(" \t \t f(\"\t\t\"); /* some\n"
11667 " \t \t comment */",
11668 Tab));
11669 EXPECT_EQ("{\n"
11670 "\t/*\n"
11671 "\t * Comment\n"
11672 "\t */\n"
11673 "\tint i;\n"
11674 "}",
11675 format("{\n"
11676 "\t/*\n"
11677 "\t * Comment\n"
11678 "\t */\n"
11679 "\t int i;\n"
11680 "}",
11681 Tab));
11682 Tab.TabWidth = 2;
11683 Tab.IndentWidth = 2;
11684 EXPECT_EQ("{\n"
11685 "\t/* aaaa\n"
11686 "\t\t bbbb */\n"
11687 "}",
11688 format("{\n"
11689 "/* aaaa\n"
11690 "\t bbbb */\n"
11691 "}",
11692 Tab));
11693 EXPECT_EQ("{\n"
11694 "\t/*\n"
11695 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11696 "\t\tbbbbbbbbbbbbb\n"
11697 "\t*/\n"
11698 "}",
11699 format("{\n"
11700 "/*\n"
11701 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11702 "*/\n"
11703 "}",
11704 Tab));
11705 Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
11706 Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
11707 Tab.TabWidth = 4;
11708 Tab.IndentWidth = 4;
11709 verifyFormat("class Assign {\n"
11710 "\tvoid f() {\n"
11711 "\t\tint x = 123;\n"
11712 "\t\tint random = 4;\n"
11713 "\t\tstd::string alphabet =\n"
11714 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11715 "\t}\n"
11716 "};",
11717 Tab);
11718
11719 Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11720 Tab.TabWidth = 8;
11721 Tab.IndentWidth = 8;
11722 EXPECT_EQ("if (aaaaaaaa && // q\n"
11723 " bb) // w\n"
11724 "\t;",
11725 format("if (aaaaaaaa &&// q\n"
11726 "bb)// w\n"
11727 ";",
11728 Tab));
11729 EXPECT_EQ("if (aaa && bbb) // w\n"
11730 "\t;",
11731 format("if(aaa&&bbb)// w\n"
11732 ";",
11733 Tab));
11734 verifyFormat("class X {\n"
11735 "\tvoid f() {\n"
11736 "\t\tsomeFunction(parameter1,\n"
11737 "\t\t parameter2);\n"
11738 "\t}\n"
11739 "};",
11740 Tab);
11741 verifyFormat("#define A \\\n"
11742 "\tvoid f() { \\\n"
11743 "\t\tsomeFunction( \\\n"
11744 "\t\t parameter1, \\\n"
11745 "\t\t parameter2); \\\n"
11746 "\t}",
11747 Tab);
11748 Tab.TabWidth = 4;
11749 Tab.IndentWidth = 8;
11750 verifyFormat("class TabWidth4Indent8 {\n"
11751 "\t\tvoid f() {\n"
11752 "\t\t\t\tsomeFunction(parameter1,\n"
11753 "\t\t\t\t parameter2);\n"
11754 "\t\t}\n"
11755 "};",
11756 Tab);
11757 Tab.TabWidth = 4;
11758 Tab.IndentWidth = 4;
11759 verifyFormat("class TabWidth4Indent4 {\n"
11760 "\tvoid f() {\n"
11761 "\t\tsomeFunction(parameter1,\n"
11762 "\t\t parameter2);\n"
11763 "\t}\n"
11764 "};",
11765 Tab);
11766 Tab.TabWidth = 8;
11767 Tab.IndentWidth = 4;
11768 verifyFormat("class TabWidth8Indent4 {\n"
11769 " void f() {\n"
11770 "\tsomeFunction(parameter1,\n"
11771 "\t parameter2);\n"
11772 " }\n"
11773 "};",
11774 Tab);
11775 Tab.TabWidth = 8;
11776 Tab.IndentWidth = 8;
11777 EXPECT_EQ("/*\n"
11778 " a\t\tcomment\n"
11779 " in multiple lines\n"
11780 " */",
11781 format(" /*\t \t \n"
11782 " \t \t a\t\tcomment\t \t\n"
11783 " \t \t in multiple lines\t\n"
11784 " \t */",
11785 Tab));
11786 verifyFormat("{\n"
11787 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11788 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11789 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11790 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11791 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11792 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11793 "};",
11794 Tab);
11795 verifyFormat("enum AA {\n"
11796 "\ta1, // Force multiple lines\n"
11797 "\ta2,\n"
11798 "\ta3\n"
11799 "};",
11800 Tab);
11801 EXPECT_EQ("if (aaaaaaaa && // q\n"
11802 " bb) // w\n"
11803 "\t;",
11804 format("if (aaaaaaaa &&// q\n"
11805 "bb)// w\n"
11806 ";",
11807 Tab));
11808 verifyFormat("class X {\n"
11809 "\tvoid f() {\n"
11810 "\t\tsomeFunction(parameter1,\n"
11811 "\t\t parameter2);\n"
11812 "\t}\n"
11813 "};",
11814 Tab);
11815 verifyFormat("{\n"
11816 "\tQ(\n"
11817 "\t {\n"
11818 "\t\t int a;\n"
11819 "\t\t someFunction(aaaaaaaa,\n"
11820 "\t\t bbbbbbb);\n"
11821 "\t },\n"
11822 "\t p);\n"
11823 "}",
11824 Tab);
11825 EXPECT_EQ("{\n"
11826 "\t/* aaaa\n"
11827 "\t bbbb */\n"
11828 "}",
11829 format("{\n"
11830 "/* aaaa\n"
11831 " bbbb */\n"
11832 "}",
11833 Tab));
11834 EXPECT_EQ("{\n"
11835 "\t/*\n"
11836 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11837 "\t bbbbbbbbbbbbb\n"
11838 "\t*/\n"
11839 "}",
11840 format("{\n"
11841 "/*\n"
11842 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11843 "*/\n"
11844 "}",
11845 Tab));
11846 EXPECT_EQ("{\n"
11847 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11848 "\t// bbbbbbbbbbbbb\n"
11849 "}",
11850 format("{\n"
11851 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11852 "}",
11853 Tab));
11854 EXPECT_EQ("{\n"
11855 "\t/*\n"
11856 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11857 "\t bbbbbbbbbbbbb\n"
11858 "\t*/\n"
11859 "}",
11860 format("{\n"
11861 "\t/*\n"
11862 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11863 "\t*/\n"
11864 "}",
11865 Tab));
11866 EXPECT_EQ("{\n"
11867 "\t/*\n"
11868 "\n"
11869 "\t*/\n"
11870 "}",
11871 format("{\n"
11872 "\t/*\n"
11873 "\n"
11874 "\t*/\n"
11875 "}",
11876 Tab));
11877 EXPECT_EQ("{\n"
11878 "\t/*\n"
11879 " asdf\n"
11880 "\t*/\n"
11881 "}",
11882 format("{\n"
11883 "\t/*\n"
11884 " asdf\n"
11885 "\t*/\n"
11886 "}",
11887 Tab));
11888 EXPECT_EQ("/* some\n"
11889 " comment */",
11890 format(" \t \t /* some\n"
11891 " \t \t comment */",
11892 Tab));
11893 EXPECT_EQ("int a; /* some\n"
11894 " comment */",
11895 format(" \t \t int a; /* some\n"
11896 " \t \t comment */",
11897 Tab));
11898 EXPECT_EQ("int a; /* some\n"
11899 "comment */",
11900 format(" \t \t int\ta; /* some\n"
11901 " \t \t comment */",
11902 Tab));
11903 EXPECT_EQ("f(\"\t\t\"); /* some\n"
11904 " comment */",
11905 format(" \t \t f(\"\t\t\"); /* some\n"
11906 " \t \t comment */",
11907 Tab));
11908 EXPECT_EQ("{\n"
11909 "\t/*\n"
11910 "\t * Comment\n"
11911 "\t */\n"
11912 "\tint i;\n"
11913 "}",
11914 format("{\n"
11915 "\t/*\n"
11916 "\t * Comment\n"
11917 "\t */\n"
11918 "\t int i;\n"
11919 "}",
11920 Tab));
11921 Tab.TabWidth = 2;
11922 Tab.IndentWidth = 2;
11923 EXPECT_EQ("{\n"
11924 "\t/* aaaa\n"
11925 "\t bbbb */\n"
11926 "}",
11927 format("{\n"
11928 "/* aaaa\n"
11929 " bbbb */\n"
11930 "}",
11931 Tab));
11932 EXPECT_EQ("{\n"
11933 "\t/*\n"
11934 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11935 "\t bbbbbbbbbbbbb\n"
11936 "\t*/\n"
11937 "}",
11938 format("{\n"
11939 "/*\n"
11940 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11941 "*/\n"
11942 "}",
11943 Tab));
11944 Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
11945 Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
11946 Tab.TabWidth = 4;
11947 Tab.IndentWidth = 4;
11948 verifyFormat("class Assign {\n"
11949 "\tvoid f() {\n"
11950 "\t\tint x = 123;\n"
11951 "\t\tint random = 4;\n"
11952 "\t\tstd::string alphabet =\n"
11953 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11954 "\t}\n"
11955 "};",
11956 Tab);
11957 Tab.AlignOperands = FormatStyle::OAS_Align;
11958 verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11959 " cccccccccccccccccccc;",
11960 Tab);
11961 // no alignment
11962 verifyFormat("int aaaaaaaaaa =\n"
11963 "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11964 Tab);
11965 verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11966 " : bbbbbbbbbbbbbb ? 222222222222222\n"
11967 " : 333333333333333;",
11968 Tab);
11969 Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11970 Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11971 verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11972 " + cccccccccccccccccccc;",
11973 Tab);
11974}
11975
11976TEST_F(FormatTest, ZeroTabWidth) {
11977 FormatStyle Tab = getLLVMStyleWithColumns(42);
11978 Tab.IndentWidth = 8;
11979 Tab.UseTab = FormatStyle::UT_Never;
11980 Tab.TabWidth = 0;
11981 EXPECT_EQ("void a(){\n"
11982 " // line starts with '\t'\n"
11983 "};",
11984 format("void a(){\n"
11985 "\t// line starts with '\t'\n"
11986 "};",
11987 Tab));
11988
11989 EXPECT_EQ("void a(){\n"
11990 " // line starts with '\t'\n"
11991 "};",
11992 format("void a(){\n"
11993 "\t\t// line starts with '\t'\n"
11994 "};",
11995 Tab));
11996
11997 Tab.UseTab = FormatStyle::UT_ForIndentation;
11998 EXPECT_EQ("void a(){\n"
11999 " // line starts with '\t'\n"
12000 "};",
12001 format("void a(){\n"
12002 "\t// line starts with '\t'\n"
12003 "};",
12004 Tab));
12005
12006 EXPECT_EQ("void a(){\n"
12007 " // line starts with '\t'\n"
12008 "};",
12009 format("void a(){\n"
12010 "\t\t// line starts with '\t'\n"
12011 "};",
12012 Tab));
12013
12014 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
12015 EXPECT_EQ("void a(){\n"
12016 " // line starts with '\t'\n"
12017 "};",
12018 format("void a(){\n"
12019 "\t// line starts with '\t'\n"
12020 "};",
12021 Tab));
12022
12023 EXPECT_EQ("void a(){\n"
12024 " // line starts with '\t'\n"
12025 "};",
12026 format("void a(){\n"
12027 "\t\t// line starts with '\t'\n"
12028 "};",
12029 Tab));
12030
12031 Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
12032 EXPECT_EQ("void a(){\n"
12033 " // line starts with '\t'\n"
12034 "};",
12035 format("void a(){\n"
12036 "\t// line starts with '\t'\n"
12037 "};",
12038 Tab));
12039
12040 EXPECT_EQ("void a(){\n"
12041 " // line starts with '\t'\n"
12042 "};",
12043 format("void a(){\n"
12044 "\t\t// line starts with '\t'\n"
12045 "};",
12046 Tab));
12047
12048 Tab.UseTab = FormatStyle::UT_Always;
12049 EXPECT_EQ("void a(){\n"
12050 "// line starts with '\t'\n"
12051 "};",
12052 format("void a(){\n"
12053 "\t// line starts with '\t'\n"
12054 "};",
12055 Tab));
12056
12057 EXPECT_EQ("void a(){\n"
12058 "// line starts with '\t'\n"
12059 "};",
12060 format("void a(){\n"
12061 "\t\t// line starts with '\t'\n"
12062 "};",
12063 Tab));
12064}
12065
12066TEST_F(FormatTest, CalculatesOriginalColumn) {
12067 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12068 "q\"; /* some\n"
12069 " comment */",
12070 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12071 "q\"; /* some\n"
12072 " comment */",
12073 getLLVMStyle()));
12074 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
12075 "/* some\n"
12076 " comment */",
12077 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
12078 " /* some\n"
12079 " comment */",
12080 getLLVMStyle()));
12081 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12082 "qqq\n"
12083 "/* some\n"
12084 " comment */",
12085 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12086 "qqq\n"
12087 " /* some\n"
12088 " comment */",
12089 getLLVMStyle()));
12090 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12091 "wwww; /* some\n"
12092 " comment */",
12093 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12094 "wwww; /* some\n"
12095 " comment */",
12096 getLLVMStyle()));
12097}
12098
12099TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
12100 FormatStyle NoSpace = getLLVMStyle();
12101 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
12102
12103 verifyFormat("while(true)\n"
12104 " continue;",
12105 NoSpace);
12106 verifyFormat("for(;;)\n"
12107 " continue;",
12108 NoSpace);
12109 verifyFormat("if(true)\n"
12110 " f();\n"
12111 "else if(true)\n"
12112 " f();",
12113 NoSpace);
12114 verifyFormat("do {\n"
12115 " do_something();\n"
12116 "} while(something());",
12117 NoSpace);
12118 verifyFormat("switch(x) {\n"
12119 "default:\n"
12120 " break;\n"
12121 "}",
12122 NoSpace);
12123 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
12124 verifyFormat("size_t x = sizeof(x);", NoSpace);
12125 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
12126 verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
12127 verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
12128 verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
12129 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
12130 verifyFormat("alignas(128) char a[128];", NoSpace);
12131 verifyFormat("size_t x = alignof(MyType);", NoSpace);
12132 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
12133 verifyFormat("int f() throw(Deprecated);", NoSpace);
12134 verifyFormat("typedef void (*cb)(int);", NoSpace);
12135 verifyFormat("T A::operator()();", NoSpace);
12136 verifyFormat("X A::operator++(T);", NoSpace);
12137 verifyFormat("auto lambda = []() { return 0; };", NoSpace);
12138
12139 FormatStyle Space = getLLVMStyle();
12140 Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
12141
12142 verifyFormat("int f ();", Space);
12143 verifyFormat("void f (int a, T b) {\n"
12144 " while (true)\n"
12145 " continue;\n"
12146 "}",
12147 Space);
12148 verifyFormat("if (true)\n"
12149 " f ();\n"
12150 "else if (true)\n"
12151 " f ();",
12152 Space);
12153 verifyFormat("do {\n"
12154 " do_something ();\n"
12155 "} while (something ());",
12156 Space);
12157 verifyFormat("switch (x) {\n"
12158 "default:\n"
12159 " break;\n"
12160 "}",
12161 Space);
12162 verifyFormat("A::A () : a (1) {}", Space);
12163 verifyFormat("void f () __attribute__ ((asdf));", Space);
12164 verifyFormat("*(&a + 1);\n"
12165 "&((&a)[1]);\n"
12166 "a[(b + c) * d];\n"
12167 "(((a + 1) * 2) + 3) * 4;",
12168 Space);
12169 verifyFormat("#define A(x) x", Space);
12170 verifyFormat("#define A (x) x", Space);
12171 verifyFormat("#if defined(x)\n"
12172 "#endif",
12173 Space);
12174 verifyFormat("auto i = std::make_unique<int> (5);", Space);
12175 verifyFormat("size_t x = sizeof (x);", Space);
12176 verifyFormat("auto f (int x) -> decltype (x);", Space);
12177 verifyFormat("auto f (int x) -> typeof (x);", Space);
12178 verifyFormat("auto f (int x) -> _Atomic (x);", Space);
12179 verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
12180 verifyFormat("int f (T x) noexcept (x.create ());", Space);
12181 verifyFormat("alignas (128) char a[128];", Space);
12182 verifyFormat("size_t x = alignof (MyType);", Space);
12183 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
12184 verifyFormat("int f () throw (Deprecated);", Space);
12185 verifyFormat("typedef void (*cb) (int);", Space);
12186 verifyFormat("T A::operator() ();", Space);
12187 verifyFormat("X A::operator++ (T);", Space);
12188 verifyFormat("auto lambda = [] () { return 0; };", Space);
12189 verifyFormat("int x = int (y);", Space);
12190
12191 FormatStyle SomeSpace = getLLVMStyle();
12192 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
12193
12194 verifyFormat("[]() -> float {}", SomeSpace);
12195 verifyFormat("[] (auto foo) {}", SomeSpace);
12196 verifyFormat("[foo]() -> int {}", SomeSpace);
12197 verifyFormat("int f();", SomeSpace);
12198 verifyFormat("void f (int a, T b) {\n"
12199 " while (true)\n"
12200 " continue;\n"
12201 "}",
12202 SomeSpace);
12203 verifyFormat("if (true)\n"
12204 " f();\n"
12205 "else if (true)\n"
12206 " f();",
12207 SomeSpace);
12208 verifyFormat("do {\n"
12209 " do_something();\n"
12210 "} while (something());",
12211 SomeSpace);
12212 verifyFormat("switch (x) {\n"
12213 "default:\n"
12214 " break;\n"
12215 "}",
12216 SomeSpace);
12217 verifyFormat("A::A() : a (1) {}", SomeSpace);
12218 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
12219 verifyFormat("*(&a + 1);\n"
12220 "&((&a)[1]);\n"
12221 "a[(b + c) * d];\n"
12222 "(((a + 1) * 2) + 3) * 4;",
12223 SomeSpace);
12224 verifyFormat("#define A(x) x", SomeSpace);
12225 verifyFormat("#define A (x) x", SomeSpace);
12226 verifyFormat("#if defined(x)\n"
12227 "#endif",
12228 SomeSpace);
12229 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
12230 verifyFormat("size_t x = sizeof (x);", SomeSpace);
12231 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
12232 verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
12233 verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
12234 verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
12235 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
12236 verifyFormat("alignas (128) char a[128];", SomeSpace);
12237 verifyFormat("size_t x = alignof (MyType);", SomeSpace);
12238 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
12239 SomeSpace);
12240 verifyFormat("int f() throw (Deprecated);", SomeSpace);
12241 verifyFormat("typedef void (*cb) (int);", SomeSpace);
12242 verifyFormat("T A::operator()();", SomeSpace);
12243 verifyFormat("X A::operator++ (T);", SomeSpace);
12244 verifyFormat("int x = int (y);", SomeSpace);
12245 verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
12246}
12247
12248TEST_F(FormatTest, SpaceAfterLogicalNot) {
12249 FormatStyle Spaces = getLLVMStyle();
12250 Spaces.SpaceAfterLogicalNot = true;
12251
12252 verifyFormat("bool x = ! y", Spaces);
12253 verifyFormat("if (! isFailure())", Spaces);
12254 verifyFormat("if (! (a && b))", Spaces);
12255 verifyFormat("\"Error!\"", Spaces);
12256 verifyFormat("! ! x", Spaces);
12257}
12258
12259TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
12260 FormatStyle Spaces = getLLVMStyle();
12261
12262 Spaces.SpacesInParentheses = true;
12263 verifyFormat("do_something( ::globalVar );", Spaces);
12264 verifyFormat("call( x, y, z );", Spaces);
12265 verifyFormat("call();", Spaces);
12266 verifyFormat("std::function<void( int, int )> callback;", Spaces);
12267 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
12268 Spaces);
12269 verifyFormat("while ( (bool)1 )\n"
12270 " continue;",
12271 Spaces);
12272 verifyFormat("for ( ;; )\n"
12273 " continue;",
12274 Spaces);
12275 verifyFormat("if ( true )\n"
12276 " f();\n"
12277 "else if ( true )\n"
12278 " f();",
12279 Spaces);
12280 verifyFormat("do {\n"
12281 " do_something( (int)i );\n"
12282 "} while ( something() );",
12283 Spaces);
12284 verifyFormat("switch ( x ) {\n"
12285 "default:\n"
12286 " break;\n"
12287 "}",
12288 Spaces);
12289
12290 Spaces.SpacesInParentheses = false;
12291 Spaces.SpacesInCStyleCastParentheses = true;
12292 verifyFormat("Type *A = ( Type * )P;", Spaces);
12293 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
12294 verifyFormat("x = ( int32 )y;", Spaces);
12295 verifyFormat("int a = ( int )(2.0f);", Spaces);
12296 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
12297 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
12298 verifyFormat("#define x (( int )-1)", Spaces);
12299
12300 // Run the first set of tests again with:
12301 Spaces.SpacesInParentheses = false;
12302 Spaces.SpaceInEmptyParentheses = true;
12303 Spaces.SpacesInCStyleCastParentheses = true;
12304 verifyFormat("call(x, y, z);", Spaces);
12305 verifyFormat("call( );", Spaces);
12306 verifyFormat("std::function<void(int, int)> callback;", Spaces);
12307 verifyFormat("while (( bool )1)\n"
12308 " continue;",
12309 Spaces);
12310 verifyFormat("for (;;)\n"
12311 " continue;",
12312 Spaces);
12313 verifyFormat("if (true)\n"
12314 " f( );\n"
12315 "else if (true)\n"
12316 " f( );",
12317 Spaces);
12318 verifyFormat("do {\n"
12319 " do_something(( int )i);\n"
12320 "} while (something( ));",
12321 Spaces);
12322 verifyFormat("switch (x) {\n"
12323 "default:\n"
12324 " break;\n"
12325 "}",
12326 Spaces);
12327
12328 // Run the first set of tests again with:
12329 Spaces.SpaceAfterCStyleCast = true;
12330 verifyFormat("call(x, y, z);", Spaces);
12331 verifyFormat("call( );", Spaces);
12332 verifyFormat("std::function<void(int, int)> callback;", Spaces);
12333 verifyFormat("while (( bool ) 1)\n"
12334 " continue;",
12335 Spaces);
12336 verifyFormat("for (;;)\n"
12337 " continue;",
12338 Spaces);
12339 verifyFormat("if (true)\n"
12340 " f( );\n"
12341 "else if (true)\n"
12342 " f( );",
12343 Spaces);
12344 verifyFormat("do {\n"
12345 " do_something(( int ) i);\n"
12346 "} while (something( ));",
12347 Spaces);
12348 verifyFormat("switch (x) {\n"
12349 "default:\n"
12350 " break;\n"
12351 "}",
12352 Spaces);
12353
12354 // Run subset of tests again with:
12355 Spaces.SpacesInCStyleCastParentheses = false;
12356 Spaces.SpaceAfterCStyleCast = true;
12357 verifyFormat("while ((bool) 1)\n"
12358 " continue;",
12359 Spaces);
12360 verifyFormat("do {\n"
12361 " do_something((int) i);\n"
12362 "} while (something( ));",
12363 Spaces);
12364
12365 verifyFormat("size_t idx = (size_t) (ptr - ((char *) file));", Spaces);
12366 verifyFormat("size_t idx = (size_t) a;", Spaces);
12367 verifyFormat("size_t idx = (size_t) (a - 1);", Spaces);
12368 verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12369 verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12370 verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12371 Spaces.SpaceAfterCStyleCast = false;
12372 verifyFormat("size_t idx = (size_t)(ptr - ((char *)file));", Spaces);
12373 verifyFormat("size_t idx = (size_t)a;", Spaces);
12374 verifyFormat("size_t idx = (size_t)(a - 1);", Spaces);
12375 verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12376 verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12377 verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12378}
12379
12380TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
12381 verifyFormat("int a[5];");
12382 verifyFormat("a[3] += 42;");
12383
12384 FormatStyle Spaces = getLLVMStyle();
12385 Spaces.SpacesInSquareBrackets = true;
12386 // Not lambdas.
12387 verifyFormat("int a[ 5 ];", Spaces);
12388 verifyFormat("a[ 3 ] += 42;", Spaces);
12389 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
12390 verifyFormat("double &operator[](int i) { return 0; }\n"
12391 "int i;",
12392 Spaces);
12393 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
12394 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
12395 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
12396 // Lambdas.
12397 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
12398 verifyFormat("return [ i, args... ] {};", Spaces);
12399 verifyFormat("int foo = [ &bar ]() {};", Spaces);
12400 verifyFormat("int foo = [ = ]() {};", Spaces);
12401 verifyFormat("int foo = [ & ]() {};", Spaces);
12402 verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
12403 verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
12404}
12405
12406TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
12407 FormatStyle NoSpaceStyle = getLLVMStyle();
12408 verifyFormat("int a[5];", NoSpaceStyle);
12409 verifyFormat("a[3] += 42;", NoSpaceStyle);
12410
12411 verifyFormat("int a[1];", NoSpaceStyle);
12412 verifyFormat("int 1 [a];", NoSpaceStyle);
12413 verifyFormat("int a[1][2];", NoSpaceStyle);
12414 verifyFormat("a[7] = 5;", NoSpaceStyle);
12415 verifyFormat("int a = (f())[23];", NoSpaceStyle);
12416 verifyFormat("f([] {})", NoSpaceStyle);
12417
12418 FormatStyle Space = getLLVMStyle();
12419 Space.SpaceBeforeSquareBrackets = true;
12420 verifyFormat("int c = []() -> int { return 2; }();\n", Space);
12421 verifyFormat("return [i, args...] {};", Space);
12422
12423 verifyFormat("int a [5];", Space);
12424 verifyFormat("a [3] += 42;", Space);
12425 verifyFormat("constexpr char hello []{\"hello\"};", Space);
12426 verifyFormat("double &operator[](int i) { return 0; }\n"
12427 "int i;",
12428 Space);
12429 verifyFormat("std::unique_ptr<int []> foo() {}", Space);
12430 verifyFormat("int i = a [a][a]->f();", Space);
12431 verifyFormat("int i = (*b) [a]->f();", Space);
12432
12433 verifyFormat("int a [1];", Space);
12434 verifyFormat("int 1 [a];", Space);
12435 verifyFormat("int a [1][2];", Space);
12436 verifyFormat("a [7] = 5;", Space);
12437 verifyFormat("int a = (f()) [23];", Space);
12438 verifyFormat("f([] {})", Space);
12439}
12440
12441TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
12442 verifyFormat("int a = 5;");
12443 verifyFormat("a += 42;");
12444 verifyFormat("a or_eq 8;");
12445
12446 FormatStyle Spaces = getLLVMStyle();
12447 Spaces.SpaceBeforeAssignmentOperators = false;
12448 verifyFormat("int a= 5;", Spaces);
12449 verifyFormat("a+= 42;", Spaces);
12450 verifyFormat("a or_eq 8;", Spaces);
12451}
12452
12453TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
12454 verifyFormat("class Foo : public Bar {};");
12455 verifyFormat("Foo::Foo() : foo(1) {}");
12456 verifyFormat("for (auto a : b) {\n}");
12457 verifyFormat("int x = a ? b : c;");
12458 verifyFormat("{\n"
12459 "label0:\n"
12460 " int x = 0;\n"
12461 "}");
12462 verifyFormat("switch (x) {\n"
12463 "case 1:\n"
12464 "default:\n"
12465 "}");
12466 verifyFormat("switch (allBraces) {\n"
12467 "case 1: {\n"
12468 " break;\n"
12469 "}\n"
12470 "case 2: {\n"
12471 " [[fallthrough]];\n"
12472 "}\n"
12473 "default: {\n"
12474 " break;\n"
12475 "}\n"
12476 "}");
12477
12478 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
12479 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
12480 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
12481 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
12482 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
12483 verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
12484 verifyFormat("{\n"
12485 "label1:\n"
12486 " int x = 0;\n"
12487 "}",
12488 CtorInitializerStyle);
12489 verifyFormat("switch (x) {\n"
12490 "case 1:\n"
12491 "default:\n"
12492 "}",
12493 CtorInitializerStyle);
12494 verifyFormat("switch (allBraces) {\n"
12495 "case 1: {\n"
12496 " break;\n"
12497 "}\n"
12498 "case 2: {\n"
12499 " [[fallthrough]];\n"
12500 "}\n"
12501 "default: {\n"
12502 " break;\n"
12503 "}\n"
12504 "}",
12505 CtorInitializerStyle);
12506 CtorInitializerStyle.BreakConstructorInitializers =
12507 FormatStyle::BCIS_AfterColon;
12508 verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12509 " aaaaaaaaaaaaaaaa(1),\n"
12510 " bbbbbbbbbbbbbbbb(2) {}",
12511 CtorInitializerStyle);
12512 CtorInitializerStyle.BreakConstructorInitializers =
12513 FormatStyle::BCIS_BeforeComma;
12514 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12515 " : aaaaaaaaaaaaaaaa(1)\n"
12516 " , bbbbbbbbbbbbbbbb(2) {}",
12517 CtorInitializerStyle);
12518 CtorInitializerStyle.BreakConstructorInitializers =
12519 FormatStyle::BCIS_BeforeColon;
12520 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12521 " : aaaaaaaaaaaaaaaa(1),\n"
12522 " bbbbbbbbbbbbbbbb(2) {}",
12523 CtorInitializerStyle);
12524 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12525 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12526 ": aaaaaaaaaaaaaaaa(1),\n"
12527 " bbbbbbbbbbbbbbbb(2) {}",
12528 CtorInitializerStyle);
12529
12530 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12531 InheritanceStyle.SpaceBeforeInheritanceColon = false;
12532 verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12533 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12534 verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12535 verifyFormat("int x = a ? b : c;", InheritanceStyle);
12536 verifyFormat("{\n"
12537 "label2:\n"
12538 " int x = 0;\n"
12539 "}",
12540 InheritanceStyle);
12541 verifyFormat("switch (x) {\n"
12542 "case 1:\n"
12543 "default:\n"
12544 "}",
12545 InheritanceStyle);
12546 verifyFormat("switch (allBraces) {\n"
12547 "case 1: {\n"
12548 " break;\n"
12549 "}\n"
12550 "case 2: {\n"
12551 " [[fallthrough]];\n"
12552 "}\n"
12553 "default: {\n"
12554 " break;\n"
12555 "}\n"
12556 "}",
12557 InheritanceStyle);
12558 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12559 verifyFormat("class Foooooooooooooooooooooo:\n"
12560 " public aaaaaaaaaaaaaaaaaa,\n"
12561 " public bbbbbbbbbbbbbbbbbb {\n"
12562 "}",
12563 InheritanceStyle);
12564 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12565 verifyFormat("class Foooooooooooooooooooooo\n"
12566 " : public aaaaaaaaaaaaaaaaaa\n"
12567 " , public bbbbbbbbbbbbbbbbbb {\n"
12568 "}",
12569 InheritanceStyle);
12570 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12571 verifyFormat("class Foooooooooooooooooooooo\n"
12572 " : public aaaaaaaaaaaaaaaaaa,\n"
12573 " public bbbbbbbbbbbbbbbbbb {\n"
12574 "}",
12575 InheritanceStyle);
12576 InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12577 verifyFormat("class Foooooooooooooooooooooo\n"
12578 ": public aaaaaaaaaaaaaaaaaa,\n"
12579 " public bbbbbbbbbbbbbbbbbb {}",
12580 InheritanceStyle);
12581
12582 FormatStyle ForLoopStyle = getLLVMStyle();
12583 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12584 verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12585 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12586 verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12587 verifyFormat("int x = a ? b : c;", ForLoopStyle);
12588 verifyFormat("{\n"
12589 "label2:\n"
12590 " int x = 0;\n"
12591 "}",
12592 ForLoopStyle);
12593 verifyFormat("switch (x) {\n"
12594 "case 1:\n"
12595 "default:\n"
12596 "}",
12597 ForLoopStyle);
12598 verifyFormat("switch (allBraces) {\n"
12599 "case 1: {\n"
12600 " break;\n"
12601 "}\n"
12602 "case 2: {\n"
12603 " [[fallthrough]];\n"
12604 "}\n"
12605 "default: {\n"
12606 " break;\n"
12607 "}\n"
12608 "}",
12609 ForLoopStyle);
12610
12611 FormatStyle CaseStyle = getLLVMStyle();
12612 CaseStyle.SpaceBeforeCaseColon = true;
12613 verifyFormat("class Foo : public Bar {};", CaseStyle);
12614 verifyFormat("Foo::Foo() : foo(1) {}", CaseStyle);
12615 verifyFormat("for (auto a : b) {\n}", CaseStyle);
12616 verifyFormat("int x = a ? b : c;", CaseStyle);
12617 verifyFormat("switch (x) {\n"
12618 "case 1 :\n"
12619 "default :\n"
12620 "}",
12621 CaseStyle);
12622 verifyFormat("switch (allBraces) {\n"
12623 "case 1 : {\n"
12624 " break;\n"
12625 "}\n"
12626 "case 2 : {\n"
12627 " [[fallthrough]];\n"
12628 "}\n"
12629 "default : {\n"
12630 " break;\n"
12631 "}\n"
12632 "}",
12633 CaseStyle);
12634
12635 FormatStyle NoSpaceStyle = getLLVMStyle();
12636 EXPECT_EQ(NoSpaceStyle.SpaceBeforeCaseColon, false);
12637 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12638 NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12639 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12640 verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12641 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12642 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12643 verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12644 verifyFormat("{\n"
12645 "label3:\n"
12646 " int x = 0;\n"
12647 "}",
12648 NoSpaceStyle);
12649 verifyFormat("switch (x) {\n"
12650 "case 1:\n"
12651 "default:\n"
12652 "}",
12653 NoSpaceStyle);
12654 verifyFormat("switch (allBraces) {\n"
12655 "case 1: {\n"
12656 " break;\n"
12657 "}\n"
12658 "case 2: {\n"
12659 " [[fallthrough]];\n"
12660 "}\n"
12661 "default: {\n"
12662 " break;\n"
12663 "}\n"
12664 "}",
12665 NoSpaceStyle);
12666
12667 FormatStyle InvertedSpaceStyle = getLLVMStyle();
12668 InvertedSpaceStyle.SpaceBeforeCaseColon = true;
12669 InvertedSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12670 InvertedSpaceStyle.SpaceBeforeInheritanceColon = false;
12671 InvertedSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12672 verifyFormat("class Foo: public Bar {};", InvertedSpaceStyle);
12673 verifyFormat("Foo::Foo(): foo(1) {}", InvertedSpaceStyle);
12674 verifyFormat("for (auto a: b) {\n}", InvertedSpaceStyle);
12675 verifyFormat("int x = a ? b : c;", InvertedSpaceStyle);
12676 verifyFormat("{\n"
12677 "label3:\n"
12678 " int x = 0;\n"
12679 "}",
12680 InvertedSpaceStyle);
12681 verifyFormat("switch (x) {\n"
12682 "case 1 :\n"
12683 "case 2 : {\n"
12684 " break;\n"
12685 "}\n"
12686 "default :\n"
12687 " break;\n"
12688 "}",
12689 InvertedSpaceStyle);
12690 verifyFormat("switch (allBraces) {\n"
12691 "case 1 : {\n"
12692 " break;\n"
12693 "}\n"
12694 "case 2 : {\n"
12695 " [[fallthrough]];\n"
12696 "}\n"
12697 "default : {\n"
12698 " break;\n"
12699 "}\n"
12700 "}",
12701 InvertedSpaceStyle);
12702}
12703
12704TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
12705 FormatStyle Style = getLLVMStyle();
12706
12707 Style.PointerAlignment = FormatStyle::PAS_Left;
12708 Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12709 verifyFormat("void* const* x = NULL;", Style);
12710
12711#define verifyQualifierSpaces(Code, Pointers, Qualifiers) \
12712 do { \
12713 Style.PointerAlignment = FormatStyle::Pointers; \
12714 Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers; \
12715 verifyFormat(Code, Style); \
12716 } while (false)
12717
12718 verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
12719 verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
12720 verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
12721
12722 verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
12723 verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
12724 verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
12725
12726 verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
12727 verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
12728 verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
12729
12730 verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
12731 verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
12732 verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
12733
12734#undef verifyQualifierSpaces
12735
12736 FormatStyle Spaces = getLLVMStyle();
12737 Spaces.AttributeMacros.push_back("qualified");
12738 Spaces.PointerAlignment = FormatStyle::PAS_Right;
12739 Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12740 verifyFormat("SomeType *volatile *a = NULL;", Spaces);
12741 verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
12742 verifyFormat("std::vector<SomeType *const *> x;", Spaces);
12743 verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
12744 verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12745 Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12746 verifyFormat("SomeType * volatile *a = NULL;", Spaces);
12747 verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
12748 verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12749 verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12750 verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12751
12752 // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
12753 Spaces.PointerAlignment = FormatStyle::PAS_Left;
12754 Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12755 verifyFormat("SomeType* volatile* a = NULL;", Spaces);
12756 verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
12757 verifyFormat("std::vector<SomeType* const*> x;", Spaces);
12758 verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
12759 verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12760 // However, setting it to SAPQ_After should add spaces after __attribute, etc.
12761 Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12762 verifyFormat("SomeType* volatile * a = NULL;", Spaces);
12763 verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
12764 verifyFormat("std::vector<SomeType* const *> x;", Spaces);
12765 verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
12766 verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12767
12768 // PAS_Middle should not have any noticeable changes even for SAPQ_Both
12769 Spaces.PointerAlignment = FormatStyle::PAS_Middle;
12770 Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12771 verifyFormat("SomeType * volatile * a = NULL;", Spaces);
12772 verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
12773 verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12774 verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12775 verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12776}
12777
12778TEST_F(FormatTest, AlignConsecutiveMacros) {
12779 FormatStyle Style = getLLVMStyle();
12780 Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
12781 Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
12782 Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
12783
12784 verifyFormat("#define a 3\n"
12785 "#define bbbb 4\n"
12786 "#define ccc (5)",
12787 Style);
12788
12789 verifyFormat("#define f(x) (x * x)\n"
12790 "#define fff(x, y, z) (x * y + z)\n"
12791 "#define ffff(x, y) (x - y)",
12792 Style);
12793
12794 verifyFormat("#define foo(x, y) (x + y)\n"
12795 "#define bar (5, 6)(2 + 2)",
12796 Style);
12797
12798 verifyFormat("#define a 3\n"
12799 "#define bbbb 4\n"
12800 "#define ccc (5)\n"
12801 "#define f(x) (x * x)\n"
12802 "#define fff(x, y, z) (x * y + z)\n"
12803 "#define ffff(x, y) (x - y)",
12804 Style);
12805
12806 Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
12807 verifyFormat("#define a 3\n"
12808 "#define bbbb 4\n"
12809 "#define ccc (5)",
12810 Style);
12811
12812 verifyFormat("#define f(x) (x * x)\n"
12813 "#define fff(x, y, z) (x * y + z)\n"
12814 "#define ffff(x, y) (x - y)",
12815 Style);
12816
12817 verifyFormat("#define foo(x, y) (x + y)\n"
12818 "#define bar (5, 6)(2 + 2)",
12819 Style);
12820
12821 verifyFormat("#define a 3\n"
12822 "#define bbbb 4\n"
12823 "#define ccc (5)\n"
12824 "#define f(x) (x * x)\n"
12825 "#define fff(x, y, z) (x * y + z)\n"
12826 "#define ffff(x, y) (x - y)",
12827 Style);
12828
12829 verifyFormat("#define a 5\n"
12830 "#define foo(x, y) (x + y)\n"
12831 "#define CCC (6)\n"
12832 "auto lambda = []() {\n"
12833 " auto ii = 0;\n"
12834 " float j = 0;\n"
12835 " return 0;\n"
12836 "};\n"
12837 "int i = 0;\n"
12838 "float i2 = 0;\n"
12839 "auto v = type{\n"
12840 " i = 1, //\n"
12841 " (i = 2), //\n"
12842 " i = 3 //\n"
12843 "};",
12844 Style);
12845
12846 Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
12847 Style.ColumnLimit = 20;
12848
12849 verifyFormat("#define a \\\n"
12850 " \"aabbbbbbbbbbbb\"\n"
12851 "#define D \\\n"
12852 " \"aabbbbbbbbbbbb\" \\\n"
12853 " \"ccddeeeeeeeee\"\n"
12854 "#define B \\\n"
12855 " \"QQQQQQQQQQQQQ\" \\\n"
12856 " \"FFFFFFFFFFFFF\" \\\n"
12857 " \"LLLLLLLL\"\n",
12858 Style);
12859
12860 Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
12861 verifyFormat("#define a \\\n"
12862 " \"aabbbbbbbbbbbb\"\n"
12863 "#define D \\\n"
12864 " \"aabbbbbbbbbbbb\" \\\n"
12865 " \"ccddeeeeeeeee\"\n"
12866 "#define B \\\n"
12867 " \"QQQQQQQQQQQQQ\" \\\n"
12868 " \"FFFFFFFFFFFFF\" \\\n"
12869 " \"LLLLLLLL\"\n",
12870 Style);
12871
12872 // Test across comments
12873 Style.MaxEmptyLinesToKeep = 10;
12874 Style.ReflowComments = false;
12875 Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossComments;
12876 EXPECT_EQ("#define a 3\n"
12877 "// line comment\n"
12878 "#define bbbb 4\n"
12879 "#define ccc (5)",
12880 format("#define a 3\n"
12881 "// line comment\n"
12882 "#define bbbb 4\n"
12883 "#define ccc (5)",
12884 Style));
12885
12886 EXPECT_EQ("#define a 3\n"
12887 "/* block comment */\n"
12888 "#define bbbb 4\n"
12889 "#define ccc (5)",
12890 format("#define a 3\n"
12891 "/* block comment */\n"
12892 "#define bbbb 4\n"
12893 "#define ccc (5)",
12894 Style));
12895
12896 EXPECT_EQ("#define a 3\n"
12897 "/* multi-line *\n"
12898 " * block comment */\n"
12899 "#define bbbb 4\n"
12900 "#define ccc (5)",
12901 format("#define a 3\n"
12902 "/* multi-line *\n"
12903 " * block comment */\n"
12904 "#define bbbb 4\n"
12905 "#define ccc (5)",
12906 Style));
12907
12908 EXPECT_EQ("#define a 3\n"
12909 "// multi-line line comment\n"
12910 "//\n"
12911 "#define bbbb 4\n"
12912 "#define ccc (5)",
12913 format("#define a 3\n"
12914 "// multi-line line comment\n"
12915 "//\n"
12916 "#define bbbb 4\n"
12917 "#define ccc (5)",
12918 Style));
12919
12920 EXPECT_EQ("#define a 3\n"
12921 "// empty lines still break.\n"
12922 "\n"
12923 "#define bbbb 4\n"
12924 "#define ccc (5)",
12925 format("#define a 3\n"
12926 "// empty lines still break.\n"
12927 "\n"
12928 "#define bbbb 4\n"
12929 "#define ccc (5)",
12930 Style));
12931
12932 // Test across empty lines
12933 Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLines;
12934 EXPECT_EQ("#define a 3\n"
12935 "\n"
12936 "#define bbbb 4\n"
12937 "#define ccc (5)",
12938 format("#define a 3\n"
12939 "\n"
12940 "#define bbbb 4\n"
12941 "#define ccc (5)",
12942 Style));
12943
12944 EXPECT_EQ("#define a 3\n"
12945 "\n"
12946 "\n"
12947 "\n"
12948 "#define bbbb 4\n"
12949 "#define ccc (5)",
12950 format("#define a 3\n"
12951 "\n"
12952 "\n"
12953 "\n"
12954 "#define bbbb 4\n"
12955 "#define ccc (5)",
12956 Style));
12957
12958 EXPECT_EQ("#define a 3\n"
12959 "// comments should break alignment\n"
12960 "//\n"
12961 "#define bbbb 4\n"
12962 "#define ccc (5)",
12963 format("#define a 3\n"
12964 "// comments should break alignment\n"
12965 "//\n"
12966 "#define bbbb 4\n"
12967 "#define ccc (5)",
12968 Style));
12969
12970 // Test across empty lines and comments
12971 Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLinesAndComments;
12972 verifyFormat("#define a 3\n"
12973 "\n"
12974 "// line comment\n"
12975 "#define bbbb 4\n"
12976 "#define ccc (5)",
12977 Style);
12978
12979 EXPECT_EQ("#define a 3\n"
12980 "\n"
12981 "\n"
12982 "/* multi-line *\n"
12983 " * block comment */\n"
12984 "\n"
12985 "\n"
12986 "#define bbbb 4\n"
12987 "#define ccc (5)",
12988 format("#define a 3\n"
12989 "\n"
12990 "\n"
12991 "/* multi-line *\n"
12992 " * block comment */\n"
12993 "\n"
12994 "\n"
12995 "#define bbbb 4\n"
12996 "#define ccc (5)",
12997 Style));
12998
12999 EXPECT_EQ("#define a 3\n"
13000 "\n"
13001 "\n"
13002 "/* multi-line *\n"
13003 " * block comment */\n"
13004 "\n"
13005 "\n"
13006 "#define bbbb 4\n"
13007 "#define ccc (5)",
13008 format("#define a 3\n"
13009 "\n"
13010 "\n"
13011 "/* multi-line *\n"
13012 " * block comment */\n"
13013 "\n"
13014 "\n"
13015 "#define bbbb 4\n"
13016 "#define ccc (5)",
13017 Style));
13018}
13019
13020TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {
13021 FormatStyle Alignment = getLLVMStyle();
13022 Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13023 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossEmptyLines;
13024
13025 Alignment.MaxEmptyLinesToKeep = 10;
13026 /* Test alignment across empty lines */
13027 EXPECT_EQ("int a = 5;\n"
13028 "\n"
13029 "int oneTwoThree = 123;",
13030 format("int a = 5;\n"
13031 "\n"
13032 "int oneTwoThree= 123;",
13033 Alignment));
13034 EXPECT_EQ("int a = 5;\n"
13035 "int one = 1;\n"
13036 "\n"
13037 "int oneTwoThree = 123;",
13038 format("int a = 5;\n"
13039 "int one = 1;\n"
13040 "\n"
13041 "int oneTwoThree = 123;",
13042 Alignment));
13043 EXPECT_EQ("int a = 5;\n"
13044 "int one = 1;\n"
13045 "\n"
13046 "int oneTwoThree = 123;\n"
13047 "int oneTwo = 12;",
13048 format("int a = 5;\n"
13049 "int one = 1;\n"
13050 "\n"
13051 "int oneTwoThree = 123;\n"
13052 "int oneTwo = 12;",
13053 Alignment));
13054
13055 /* Test across comments */
13056 EXPECT_EQ("int a = 5;\n"
13057 "/* block comment */\n"
13058 "int oneTwoThree = 123;",
13059 format("int a = 5;\n"
13060 "/* block comment */\n"
13061 "int oneTwoThree=123;",
13062 Alignment));
13063
13064 EXPECT_EQ("int a = 5;\n"
13065 "// line comment\n"
13066 "int oneTwoThree = 123;",
13067 format("int a = 5;\n"
13068 "// line comment\n"
13069 "int oneTwoThree=123;",
13070 Alignment));
13071
13072 /* Test across comments and newlines */
13073 EXPECT_EQ("int a = 5;\n"
13074 "\n"
13075 "/* block comment */\n"
13076 "int oneTwoThree = 123;",
13077 format("int a = 5;\n"
13078 "\n"
13079 "/* block comment */\n"
13080 "int oneTwoThree=123;",
13081 Alignment));
13082
13083 EXPECT_EQ("int a = 5;\n"
13084 "\n"
13085 "// line comment\n"
13086 "int oneTwoThree = 123;",
13087 format("int a = 5;\n"
13088 "\n"
13089 "// line comment\n"
13090 "int oneTwoThree=123;",
13091 Alignment));
13092}
13093
13094TEST_F(FormatTest, AlignConsecutiveDeclarationsAcrossEmptyLinesAndComments) {
13095 FormatStyle Alignment = getLLVMStyle();
13096 Alignment.AlignConsecutiveDeclarations =
13097 FormatStyle::ACS_AcrossEmptyLinesAndComments;
13098 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
13099
13100 Alignment.MaxEmptyLinesToKeep = 10;
13101 /* Test alignment across empty lines */
13102 EXPECT_EQ("int a = 5;\n"
13103 "\n"
13104 "float const oneTwoThree = 123;",
13105 format("int a = 5;\n"
13106 "\n"
13107 "float const oneTwoThree = 123;",
13108 Alignment));
13109 EXPECT_EQ("int a = 5;\n"
13110 "float const one = 1;\n"
13111 "\n"
13112 "int oneTwoThree = 123;",
13113 format("int a = 5;\n"
13114 "float const one = 1;\n"
13115 "\n"
13116 "int oneTwoThree = 123;",
13117 Alignment));
13118
13119 /* Test across comments */
13120 EXPECT_EQ("float const a = 5;\n"
13121 "/* block comment */\n"
13122 "int oneTwoThree = 123;",
13123 format("float const a = 5;\n"
13124 "/* block comment */\n"
13125 "int oneTwoThree=123;",
13126 Alignment));
13127
13128 EXPECT_EQ("float const a = 5;\n"
13129 "// line comment\n"
13130 "int oneTwoThree = 123;",
13131 format("float const a = 5;\n"
13132 "// line comment\n"
13133 "int oneTwoThree=123;",
13134 Alignment));
13135
13136 /* Test across comments and newlines */
13137 EXPECT_EQ("float const a = 5;\n"
13138 "\n"
13139 "/* block comment */\n"
13140 "int oneTwoThree = 123;",
13141 format("float const a = 5;\n"
13142 "\n"
13143 "/* block comment */\n"
13144 "int oneTwoThree=123;",
13145 Alignment));
13146
13147 EXPECT_EQ("float const a = 5;\n"
13148 "\n"
13149 "// line comment\n"
13150 "int oneTwoThree = 123;",
13151 format("float const a = 5;\n"
13152 "\n"
13153 "// line comment\n"
13154 "int oneTwoThree=123;",
13155 Alignment));
13156}
13157
13158TEST_F(FormatTest, AlignConsecutiveBitFieldsAcrossEmptyLinesAndComments) {
13159 FormatStyle Alignment = getLLVMStyle();
13160 Alignment.AlignConsecutiveBitFields =
13161 FormatStyle::ACS_AcrossEmptyLinesAndComments;
13162
13163 Alignment.MaxEmptyLinesToKeep = 10;
13164 /* Test alignment across empty lines */
13165 EXPECT_EQ("int a : 5;\n"
13166 "\n"
13167 "int longbitfield : 6;",
13168 format("int a : 5;\n"
13169 "\n"
13170 "int longbitfield : 6;",
13171 Alignment));
13172 EXPECT_EQ("int a : 5;\n"
13173 "int one : 1;\n"
13174 "\n"
13175 "int longbitfield : 6;",
13176 format("int a : 5;\n"
13177 "int one : 1;\n"
13178 "\n"
13179 "int longbitfield : 6;",
13180 Alignment));
13181
13182 /* Test across comments */
13183 EXPECT_EQ("int a : 5;\n"
13184 "/* block comment */\n"
13185 "int longbitfield : 6;",
13186 format("int a : 5;\n"
13187 "/* block comment */\n"
13188 "int longbitfield : 6;",
13189 Alignment));
13190 EXPECT_EQ("int a : 5;\n"
13191 "int one : 1;\n"
13192 "// line comment\n"
13193 "int longbitfield : 6;",
13194 format("int a : 5;\n"
13195 "int one : 1;\n"
13196 "// line comment\n"
13197 "int longbitfield : 6;",
13198 Alignment));
13199
13200 /* Test across comments and newlines */
13201 EXPECT_EQ("int a : 5;\n"
13202 "/* block comment */\n"
13203 "\n"
13204 "int longbitfield : 6;",
13205 format("int a : 5;\n"
13206 "/* block comment */\n"
13207 "\n"
13208 "int longbitfield : 6;",
13209 Alignment));
13210 EXPECT_EQ("int a : 5;\n"
13211 "int one : 1;\n"
13212 "\n"
13213 "// line comment\n"
13214 "\n"
13215 "int longbitfield : 6;",
13216 format("int a : 5;\n"
13217 "int one : 1;\n"
13218 "\n"
13219 "// line comment \n"
13220 "\n"
13221 "int longbitfield : 6;",
13222 Alignment));
13223}
13224
13225TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) {
13226 FormatStyle Alignment = getLLVMStyle();
13227 Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13228 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossComments;
13229
13230 Alignment.MaxEmptyLinesToKeep = 10;
13231 /* Test alignment across empty lines */
13232 EXPECT_EQ("int a = 5;\n"
13233 "\n"
13234 "int oneTwoThree = 123;",
13235 format("int a = 5;\n"
13236 "\n"
13237 "int oneTwoThree= 123;",
13238 Alignment));
13239 EXPECT_EQ("int a = 5;\n"
13240 "int one = 1;\n"
13241 "\n"
13242 "int oneTwoThree = 123;",
13243 format("int a = 5;\n"
13244 "int one = 1;\n"
13245 "\n"
13246 "int oneTwoThree = 123;",
13247 Alignment));
13248
13249 /* Test across comments */
13250 EXPECT_EQ("int a = 5;\n"
13251 "/* block comment */\n"
13252 "int oneTwoThree = 123;",
13253 format("int a = 5;\n"
13254 "/* block comment */\n"
13255 "int oneTwoThree=123;",
13256 Alignment));
13257
13258 EXPECT_EQ("int a = 5;\n"
13259 "// line comment\n"
13260 "int oneTwoThree = 123;",
13261 format("int a = 5;\n"
13262 "// line comment\n"
13263 "int oneTwoThree=123;",
13264 Alignment));
13265
13266 EXPECT_EQ("int a = 5;\n"
13267 "/*\n"
13268 " * multi-line block comment\n"
13269 " */\n"
13270 "int oneTwoThree = 123;",
13271 format("int a = 5;\n"
13272 "/*\n"
13273 " * multi-line block comment\n"
13274 " */\n"
13275 "int oneTwoThree=123;",
13276 Alignment));
13277
13278 EXPECT_EQ("int a = 5;\n"
13279 "//\n"
13280 "// multi-line line comment\n"
13281 "//\n"
13282 "int oneTwoThree = 123;",
13283 format("int a = 5;\n"
13284 "//\n"
13285 "// multi-line line comment\n"
13286 "//\n"
13287 "int oneTwoThree=123;",
13288 Alignment));
13289
13290 /* Test across comments and newlines */
13291 EXPECT_EQ("int a = 5;\n"
13292 "\n"
13293 "/* block comment */\n"
13294 "int oneTwoThree = 123;",
13295 format("int a = 5;\n"
13296 "\n"
13297 "/* block comment */\n"
13298 "int oneTwoThree=123;",
13299 Alignment));
13300
13301 EXPECT_EQ("int a = 5;\n"
13302 "\n"
13303 "// line comment\n"
13304 "int oneTwoThree = 123;",
13305 format("int a = 5;\n"
13306 "\n"
13307 "// line comment\n"
13308 "int oneTwoThree=123;",
13309 Alignment));
13310}
13311
13312TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLinesAndComments) {
13313 FormatStyle Alignment = getLLVMStyle();
13314 Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13315 Alignment.AlignConsecutiveAssignments =
13316 FormatStyle::ACS_AcrossEmptyLinesAndComments;
13317 verifyFormat("int a = 5;\n"
13318 "int oneTwoThree = 123;",
13319 Alignment);
13320 verifyFormat("int a = method();\n"
13321 "int oneTwoThree = 133;",
13322 Alignment);
13323 verifyFormat("a &= 5;\n"
13324 "bcd *= 5;\n"
13325 "ghtyf += 5;\n"
13326 "dvfvdb -= 5;\n"
13327 "a /= 5;\n"
13328 "vdsvsv %= 5;\n"
13329 "sfdbddfbdfbb ^= 5;\n"
13330 "dvsdsv |= 5;\n"
13331 "int dsvvdvsdvvv = 123;",
13332 Alignment);
13333 verifyFormat("int i = 1, j = 10;\n"
13334 "something = 2000;",
13335 Alignment);
13336 verifyFormat("something = 2000;\n"
13337 "int i = 1, j = 10;\n",
13338 Alignment);
13339 verifyFormat("something = 2000;\n"
13340 "another = 911;\n"
13341 "int i = 1, j = 10;\n"
13342 "oneMore = 1;\n"
13343 "i = 2;",
13344 Alignment);
13345 verifyFormat("int a = 5;\n"
13346 "int one = 1;\n"
13347 "method();\n"
13348 "int oneTwoThree = 123;\n"
13349 "int oneTwo = 12;",
13350 Alignment);
13351 verifyFormat("int oneTwoThree = 123;\n"
13352 "int oneTwo = 12;\n"
13353 "method();\n",
13354 Alignment);
13355 verifyFormat("int oneTwoThree = 123; // comment\n"
13356 "int oneTwo = 12; // comment",
13357 Alignment);
13358
13359 // Bug 25167
13360 /* Uncomment when fixed
13361 verifyFormat("#if A\n"
13362 "#else\n"
13363 "int aaaaaaaa = 12;\n"
13364 "#endif\n"
13365 "#if B\n"
13366 "#else\n"
13367 "int a = 12;\n"
13368 "#endif\n",
13369 Alignment);
13370 verifyFormat("enum foo {\n"
13371 "#if A\n"
13372 "#else\n"
13373 " aaaaaaaa = 12;\n"
13374 "#endif\n"
13375 "#if B\n"
13376 "#else\n"
13377 " a = 12;\n"
13378 "#endif\n"
13379 "};\n",
13380 Alignment);
13381 */
13382
13383 Alignment.MaxEmptyLinesToKeep = 10;
13384 /* Test alignment across empty lines */
13385 EXPECT_EQ("int a = 5;\n"
13386 "\n"
13387 "int oneTwoThree = 123;",
13388 format("int a = 5;\n"
13389 "\n"
13390 "int oneTwoThree= 123;",
13391 Alignment));
13392 EXPECT_EQ("int a = 5;\n"
13393 "int one = 1;\n"
13394 "\n"
13395 "int oneTwoThree = 123;",
13396 format("int a = 5;\n"
13397 "int one = 1;\n"
13398 "\n"
13399 "int oneTwoThree = 123;",
13400 Alignment));
13401 EXPECT_EQ("int a = 5;\n"
13402 "int one = 1;\n"
13403 "\n"
13404 "int oneTwoThree = 123;\n"
13405 "int oneTwo = 12;",
13406 format("int a = 5;\n"
13407 "int one = 1;\n"
13408 "\n"
13409 "int oneTwoThree = 123;\n"
13410 "int oneTwo = 12;",
13411 Alignment));
13412
13413 /* Test across comments */
13414 EXPECT_EQ("int a = 5;\n"
13415 "/* block comment */\n"
13416 "int oneTwoThree = 123;",
13417 format("int a = 5;\n"
13418 "/* block comment */\n"
13419 "int oneTwoThree=123;",
13420 Alignment));
13421
13422 EXPECT_EQ("int a = 5;\n"
13423 "// line comment\n"
13424 "int oneTwoThree = 123;",
13425 format("int a = 5;\n"
13426 "// line comment\n"
13427 "int oneTwoThree=123;",
13428 Alignment));
13429
13430 /* Test across comments and newlines */
13431 EXPECT_EQ("int a = 5;\n"
13432 "\n"
13433 "/* block comment */\n"
13434 "int oneTwoThree = 123;",
13435 format("int a = 5;\n"
13436 "\n"
13437 "/* block comment */\n"
13438 "int oneTwoThree=123;",
13439 Alignment));
13440
13441 EXPECT_EQ("int a = 5;\n"
13442 "\n"
13443 "// line comment\n"
13444 "int oneTwoThree = 123;",
13445 format("int a = 5;\n"
13446 "\n"
13447 "// line comment\n"
13448 "int oneTwoThree=123;",
13449 Alignment));
13450
13451 EXPECT_EQ("int a = 5;\n"
13452 "//\n"
13453 "// multi-line line comment\n"
13454 "//\n"
13455 "int oneTwoThree = 123;",
13456 format("int a = 5;\n"
13457 "//\n"
13458 "// multi-line line comment\n"
13459 "//\n"
13460 "int oneTwoThree=123;",
13461 Alignment));
13462
13463 EXPECT_EQ("int a = 5;\n"
13464 "/*\n"
13465 " * multi-line block comment\n"
13466 " */\n"
13467 "int oneTwoThree = 123;",
13468 format("int a = 5;\n"
13469 "/*\n"
13470 " * multi-line block comment\n"
13471 " */\n"
13472 "int oneTwoThree=123;",
13473 Alignment));
13474
13475 EXPECT_EQ("int a = 5;\n"
13476 "\n"
13477 "/* block comment */\n"
13478 "\n"
13479 "\n"
13480 "\n"
13481 "int oneTwoThree = 123;",
13482 format("int a = 5;\n"
13483 "\n"
13484 "/* block comment */\n"
13485 "\n"
13486 "\n"
13487 "\n"
13488 "int oneTwoThree=123;",
13489 Alignment));
13490
13491 EXPECT_EQ("int a = 5;\n"
13492 "\n"
13493 "// line comment\n"
13494 "\n"
13495 "\n"
13496 "\n"
13497 "int oneTwoThree = 123;",
13498 format("int a = 5;\n"
13499 "\n"
13500 "// line comment\n"
13501 "\n"
13502 "\n"
13503 "\n"
13504 "int oneTwoThree=123;",
13505 Alignment));
13506
13507 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
13508 verifyFormat("#define A \\\n"
13509 " int aaaa = 12; \\\n"
13510 " int b = 23; \\\n"
13511 " int ccc = 234; \\\n"
13512 " int dddddddddd = 2345;",
13513 Alignment);
13514 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13515 verifyFormat("#define A \\\n"
13516 " int aaaa = 12; \\\n"
13517 " int b = 23; \\\n"
13518 " int ccc = 234; \\\n"
13519 " int dddddddddd = 2345;",
13520 Alignment);
13521 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
13522 verifyFormat("#define A "
13523 " \\\n"
13524 " int aaaa = 12; "
13525 " \\\n"
13526 " int b = 23; "
13527 " \\\n"
13528 " int ccc = 234; "
13529 " \\\n"
13530 " int dddddddddd = 2345;",
13531 Alignment);
13532 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
13533 "k = 4, int l = 5,\n"
13534 " int m = 6) {\n"
13535 " int j = 10;\n"
13536 " otherThing = 1;\n"
13537 "}",
13538 Alignment);
13539 verifyFormat("void SomeFunction(int parameter = 0) {\n"
13540 " int i = 1;\n"
13541 " int j = 2;\n"
13542 " int big = 10000;\n"
13543 "}",
13544 Alignment);
13545 verifyFormat("class C {\n"
13546 "public:\n"
13547 " int i = 1;\n"
13548 " virtual void f() = 0;\n"
13549 "};",
13550 Alignment);
13551 verifyFormat("int i = 1;\n"
13552 "if (SomeType t = getSomething()) {\n"
13553 "}\n"
13554 "int j = 2;\n"
13555 "int big = 10000;",
13556 Alignment);
13557 verifyFormat("int j = 7;\n"
13558 "for (int k = 0; k < N; ++k) {\n"
13559 "}\n"
13560 "int j = 2;\n"
13561 "int big = 10000;\n"
13562 "}",
13563 Alignment);
13564 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13565 verifyFormat("int i = 1;\n"
13566 "LooooooooooongType loooooooooooooooooooooongVariable\n"
13567 " = someLooooooooooooooooongFunction();\n"
13568 "int j = 2;",
13569 Alignment);
13570 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
13571 verifyFormat("int i = 1;\n"
13572 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
13573 " someLooooooooooooooooongFunction();\n"
13574 "int j = 2;",
13575 Alignment);
13576
13577 verifyFormat("auto lambda = []() {\n"
13578 " auto i = 0;\n"
13579 " return 0;\n"
13580 "};\n"
13581 "int i = 0;\n"
13582 "auto v = type{\n"
13583 " i = 1, //\n"
13584 " (i = 2), //\n"
13585 " i = 3 //\n"
13586 "};",
13587 Alignment);
13588
13589 verifyFormat(
13590 "int i = 1;\n"
13591 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
13592 " loooooooooooooooooooooongParameterB);\n"
13593 "int j = 2;",
13594 Alignment);
13595
13596 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
13597 " typename B = very_long_type_name_1,\n"
13598 " typename T_2 = very_long_type_name_2>\n"
13599 "auto foo() {}\n",
13600 Alignment);
13601 verifyFormat("int a, b = 1;\n"
13602 "int c = 2;\n"
13603 "int dd = 3;\n",
13604 Alignment);
13605 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
13606 "float b[1][] = {{3.f}};\n",
13607 Alignment);
13608 verifyFormat("for (int i = 0; i < 1; i++)\n"
13609 " int x = 1;\n",
13610 Alignment);
13611 verifyFormat("for (i = 0; i < 1; i++)\n"
13612 " x = 1;\n"
13613 "y = 1;\n",
13614 Alignment);
13615
13616 Alignment.ReflowComments = true;
13617 Alignment.ColumnLimit = 50;
13618 EXPECT_EQ("int x = 0;\n"
13619 "int yy = 1; /// specificlennospace\n"
13620 "int zzz = 2;\n",
13621 format("int x = 0;\n"
13622 "int yy = 1; ///specificlennospace\n"
13623 "int zzz = 2;\n",
13624 Alignment));
13625}
13626
13627TEST_F(FormatTest, AlignConsecutiveAssignments) {
13628 FormatStyle Alignment = getLLVMStyle();
13629 Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13630 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
13631 verifyFormat("int a = 5;\n"
13632 "int oneTwoThree = 123;",
13633 Alignment);
13634 verifyFormat("int a = 5;\n"
13635 "int oneTwoThree = 123;",
13636 Alignment);
13637
13638 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13639 verifyFormat("int a = 5;\n"
13640 "int oneTwoThree = 123;",
13641 Alignment);
13642 verifyFormat("int a = method();\n"
13643 "int oneTwoThree = 133;",
13644 Alignment);
13645 verifyFormat("a &= 5;\n"
13646 "bcd *= 5;\n"
13647 "ghtyf += 5;\n"
13648 "dvfvdb -= 5;\n"
13649 "a /= 5;\n"
13650 "vdsvsv %= 5;\n"
13651 "sfdbddfbdfbb ^= 5;\n"
13652 "dvsdsv |= 5;\n"
13653 "int dsvvdvsdvvv = 123;",
13654 Alignment);
13655 verifyFormat("int i = 1, j = 10;\n"
13656 "something = 2000;",
13657 Alignment);
13658 verifyFormat("something = 2000;\n"
13659 "int i = 1, j = 10;\n",
13660 Alignment);
13661 verifyFormat("something = 2000;\n"
13662 "another = 911;\n"
13663 "int i = 1, j = 10;\n"
13664 "oneMore = 1;\n"
13665 "i = 2;",
13666 Alignment);
13667 verifyFormat("int a = 5;\n"
13668 "int one = 1;\n"
13669 "method();\n"
13670 "int oneTwoThree = 123;\n"
13671 "int oneTwo = 12;",
13672 Alignment);
13673 verifyFormat("int oneTwoThree = 123;\n"
13674 "int oneTwo = 12;\n"
13675 "method();\n",
13676 Alignment);
13677 verifyFormat("int oneTwoThree = 123; // comment\n"
13678 "int oneTwo = 12; // comment",
13679 Alignment);
13680
13681 // Bug 25167
13682 /* Uncomment when fixed
13683 verifyFormat("#if A\n"
13684 "#else\n"
13685 "int aaaaaaaa = 12;\n"
13686 "#endif\n"
13687 "#if B\n"
13688 "#else\n"
13689 "int a = 12;\n"
13690 "#endif\n",
13691 Alignment);
13692 verifyFormat("enum foo {\n"
13693 "#if A\n"
13694 "#else\n"
13695 " aaaaaaaa = 12;\n"
13696 "#endif\n"
13697 "#if B\n"
13698 "#else\n"
13699 " a = 12;\n"
13700 "#endif\n"
13701 "};\n",
13702 Alignment);
13703 */
13704
13705 EXPECT_EQ("int a = 5;\n"
13706 "\n"
13707 "int oneTwoThree = 123;",
13708 format("int a = 5;\n"
13709 "\n"
13710 "int oneTwoThree= 123;",
13711 Alignment));
13712 EXPECT_EQ("int a = 5;\n"
13713 "int one = 1;\n"
13714 "\n"
13715 "int oneTwoThree = 123;",
13716 format("int a = 5;\n"
13717 "int one = 1;\n"
13718 "\n"
13719 "int oneTwoThree = 123;",
13720 Alignment));
13721 EXPECT_EQ("int a = 5;\n"
13722 "int one = 1;\n"
13723 "\n"
13724 "int oneTwoThree = 123;\n"
13725 "int oneTwo = 12;",
13726 format("int a = 5;\n"
13727 "int one = 1;\n"
13728 "\n"
13729 "int oneTwoThree = 123;\n"
13730 "int oneTwo = 12;",
13731 Alignment));
13732 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
13733 verifyFormat("#define A \\\n"
13734 " int aaaa = 12; \\\n"
13735 " int b = 23; \\\n"
13736 " int ccc = 234; \\\n"
13737 " int dddddddddd = 2345;",
13738 Alignment);
13739 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13740 verifyFormat("#define A \\\n"
13741 " int aaaa = 12; \\\n"
13742 " int b = 23; \\\n"
13743 " int ccc = 234; \\\n"
13744 " int dddddddddd = 2345;",
13745 Alignment);
13746 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
13747 verifyFormat("#define A "
13748 " \\\n"
13749 " int aaaa = 12; "
13750 " \\\n"
13751 " int b = 23; "
13752 " \\\n"
13753 " int ccc = 234; "
13754 " \\\n"
13755 " int dddddddddd = 2345;",
13756 Alignment);
13757 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
13758 "k = 4, int l = 5,\n"
13759 " int m = 6) {\n"
13760 " int j = 10;\n"
13761 " otherThing = 1;\n"
13762 "}",
13763 Alignment);
13764 verifyFormat("void SomeFunction(int parameter = 0) {\n"
13765 " int i = 1;\n"
13766 " int j = 2;\n"
13767 " int big = 10000;\n"
13768 "}",
13769 Alignment);
13770 verifyFormat("class C {\n"
13771 "public:\n"
13772 " int i = 1;\n"
13773 " virtual void f() = 0;\n"
13774 "};",
13775 Alignment);
13776 verifyFormat("int i = 1;\n"
13777 "if (SomeType t = getSomething()) {\n"
13778 "}\n"
13779 "int j = 2;\n"
13780 "int big = 10000;",
13781 Alignment);
13782 verifyFormat("int j = 7;\n"
13783 "for (int k = 0; k < N; ++k) {\n"
13784 "}\n"
13785 "int j = 2;\n"
13786 "int big = 10000;\n"
13787 "}",
13788 Alignment);
13789 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13790 verifyFormat("int i = 1;\n"
13791 "LooooooooooongType loooooooooooooooooooooongVariable\n"
13792 " = someLooooooooooooooooongFunction();\n"
13793 "int j = 2;",
13794 Alignment);
13795 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
13796 verifyFormat("int i = 1;\n"
13797 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
13798 " someLooooooooooooooooongFunction();\n"
13799 "int j = 2;",
13800 Alignment);
13801
13802 verifyFormat("auto lambda = []() {\n"
13803 " auto i = 0;\n"
13804 " return 0;\n"
13805 "};\n"
13806 "int i = 0;\n"
13807 "auto v = type{\n"
13808 " i = 1, //\n"
13809 " (i = 2), //\n"
13810 " i = 3 //\n"
13811 "};",
13812 Alignment);
13813
13814 verifyFormat(
13815 "int i = 1;\n"
13816 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
13817 " loooooooooooooooooooooongParameterB);\n"
13818 "int j = 2;",
13819 Alignment);
13820
13821 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
13822 " typename B = very_long_type_name_1,\n"
13823 " typename T_2 = very_long_type_name_2>\n"
13824 "auto foo() {}\n",
13825 Alignment);
13826 verifyFormat("int a, b = 1;\n"
13827 "int c = 2;\n"
13828 "int dd = 3;\n",
13829 Alignment);
13830 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
13831 "float b[1][] = {{3.f}};\n",
13832 Alignment);
13833 verifyFormat("for (int i = 0; i < 1; i++)\n"
13834 " int x = 1;\n",
13835 Alignment);
13836 verifyFormat("for (i = 0; i < 1; i++)\n"
13837 " x = 1;\n"
13838 "y = 1;\n",
13839 Alignment);
13840
13841 Alignment.ReflowComments = true;
13842 Alignment.ColumnLimit = 50;
13843 EXPECT_EQ("int x = 0;\n"
13844 "int yy = 1; /// specificlennospace\n"
13845 "int zzz = 2;\n",
13846 format("int x = 0;\n"
13847 "int yy = 1; ///specificlennospace\n"
13848 "int zzz = 2;\n",
13849 Alignment));
13850}
13851
13852TEST_F(FormatTest, AlignConsecutiveBitFields) {
13853 FormatStyle Alignment = getLLVMStyle();
13854 Alignment.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
13855 verifyFormat("int const a : 5;\n"
13856 "int oneTwoThree : 23;",
13857 Alignment);
13858
13859 // Initializers are allowed starting with c++2a
13860 verifyFormat("int const a : 5 = 1;\n"
13861 "int oneTwoThree : 23 = 0;",
13862 Alignment);
13863
13864 Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13865 verifyFormat("int const a : 5;\n"
13866 "int oneTwoThree : 23;",
13867 Alignment);
13868
13869 verifyFormat("int const a : 5; // comment\n"
13870 "int oneTwoThree : 23; // comment",
13871 Alignment);
13872
13873 verifyFormat("int const a : 5 = 1;\n"
13874 "int oneTwoThree : 23 = 0;",
13875 Alignment);
13876
13877 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13878 verifyFormat("int const a : 5 = 1;\n"
13879 "int oneTwoThree : 23 = 0;",
13880 Alignment);
13881 verifyFormat("int const a : 5 = {1};\n"
13882 "int oneTwoThree : 23 = 0;",
13883 Alignment);
13884
13885 Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
13886 verifyFormat("int const a :5;\n"
13887 "int oneTwoThree:23;",
13888 Alignment);
13889
13890 Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
13891 verifyFormat("int const a :5;\n"
13892 "int oneTwoThree :23;",
13893 Alignment);
13894
13895 Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
13896 verifyFormat("int const a : 5;\n"
13897 "int oneTwoThree: 23;",
13898 Alignment);
13899
13900 // Known limitations: ':' is only recognized as a bitfield colon when
13901 // followed by a number.
13902 /*
13903 verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
13904 "int a : 5;",
13905 Alignment);
13906 */
13907}
13908
13909TEST_F(FormatTest, AlignConsecutiveDeclarations) {
13910 FormatStyle Alignment = getLLVMStyle();
13911 Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13912 Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_None;
13913 verifyFormat("float const a = 5;\n"
13914 "int oneTwoThree = 123;",
13915 Alignment);
13916 verifyFormat("int a = 5;\n"
13917 "float const oneTwoThree = 123;",
13918 Alignment);
13919
13920 Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13921 verifyFormat("float const a = 5;\n"
13922 "int oneTwoThree = 123;",
13923 Alignment);
13924 verifyFormat("int a = method();\n"
13925 "float const oneTwoThree = 133;",
13926 Alignment);
13927 verifyFormat("int i = 1, j = 10;\n"
13928 "something = 2000;",
13929 Alignment);
13930 verifyFormat("something = 2000;\n"
13931 "int i = 1, j = 10;\n",
13932 Alignment);
13933 verifyFormat("float something = 2000;\n"
13934 "double another = 911;\n"
13935 "int i = 1, j = 10;\n"
13936 "const int *oneMore = 1;\n"
13937 "unsigned i = 2;",
13938 Alignment);
13939 verifyFormat("float a = 5;\n"
13940 "int one = 1;\n"
13941 "method();\n"
13942 "const double oneTwoThree = 123;\n"
13943 "const unsigned int oneTwo = 12;",
13944 Alignment);
13945 verifyFormat("int oneTwoThree{0}; // comment\n"
13946 "unsigned oneTwo; // comment",
13947 Alignment);
13948 EXPECT_EQ("float const a = 5;\n"
13949 "\n"
13950 "int oneTwoThree = 123;",
13951 format("float const a = 5;\n"
13952 "\n"
13953 "int oneTwoThree= 123;",
13954 Alignment));
13955 EXPECT_EQ("float a = 5;\n"
13956 "int one = 1;\n"
13957 "\n"
13958 "unsigned oneTwoThree = 123;",
13959 format("float a = 5;\n"
13960 "int one = 1;\n"
13961 "\n"
13962 "unsigned oneTwoThree = 123;",
13963 Alignment));
13964 EXPECT_EQ("float a = 5;\n"
13965 "int one = 1;\n"
13966 "\n"
13967 "unsigned oneTwoThree = 123;\n"
13968 "int oneTwo = 12;",
13969 format("float a = 5;\n"
13970 "int one = 1;\n"
13971 "\n"
13972 "unsigned oneTwoThree = 123;\n"
13973 "int oneTwo = 12;",
13974 Alignment));
13975 // Function prototype alignment
13976 verifyFormat("int a();\n"
13977 "double b();",
13978 Alignment);
13979 verifyFormat("int a(int x);\n"
13980 "double b();",
13981 Alignment);
13982 unsigned OldColumnLimit = Alignment.ColumnLimit;
13983 // We need to set ColumnLimit to zero, in order to stress nested alignments,
13984 // otherwise the function parameters will be re-flowed onto a single line.
13985 Alignment.ColumnLimit = 0;
13986 EXPECT_EQ("int a(int x,\n"
13987 " float y);\n"
13988 "double b(int x,\n"
13989 " double y);",
13990 format("int a(int x,\n"
13991 " float y);\n"
13992 "double b(int x,\n"
13993 " double y);",
13994 Alignment));
13995 // This ensures that function parameters of function declarations are
13996 // correctly indented when their owning functions are indented.
13997 // The failure case here is for 'double y' to not be indented enough.
13998 EXPECT_EQ("double a(int x);\n"
13999 "int b(int y,\n"
14000 " double z);",
14001 format("double a(int x);\n"
14002 "int b(int y,\n"
14003 " double z);",
14004 Alignment));
14005 // Set ColumnLimit low so that we induce wrapping immediately after
14006 // the function name and opening paren.
14007 Alignment.ColumnLimit = 13;
14008 verifyFormat("int function(\n"
14009 " int x,\n"
14010 " bool y);",
14011 Alignment);
14012 Alignment.ColumnLimit = OldColumnLimit;
14013 // Ensure function pointers don't screw up recursive alignment
14014 verifyFormat("int a(int x, void (*fp)(int y));\n"
14015 "double b();",
14016 Alignment);
14017 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14018 // Ensure recursive alignment is broken by function braces, so that the
14019 // "a = 1" does not align with subsequent assignments inside the function
14020 // body.
14021 verifyFormat("int func(int a = 1) {\n"
14022 " int b = 2;\n"
14023 " int cc = 3;\n"
14024 "}",
14025 Alignment);
14026 verifyFormat("float something = 2000;\n"
14027 "double another = 911;\n"
14028 "int i = 1, j = 10;\n"
14029 "const int *oneMore = 1;\n"
14030 "unsigned i = 2;",
14031 Alignment);
14032 verifyFormat("int oneTwoThree = {0}; // comment\n"
14033 "unsigned oneTwo = 0; // comment",
14034 Alignment);
14035 // Make sure that scope is correctly tracked, in the absence of braces
14036 verifyFormat("for (int i = 0; i < n; i++)\n"
14037 " j = i;\n"
14038 "double x = 1;\n",
14039 Alignment);
14040 verifyFormat("if (int i = 0)\n"
14041 " j = i;\n"
14042 "double x = 1;\n",
14043 Alignment);
14044 // Ensure operator[] and operator() are comprehended
14045 verifyFormat("struct test {\n"
14046 " long long int foo();\n"
14047 " int operator[](int a);\n"
14048 " double bar();\n"
14049 "};\n",
14050 Alignment);
14051 verifyFormat("struct test {\n"
14052 " long long int foo();\n"
14053 " int operator()(int a);\n"
14054 " double bar();\n"
14055 "};\n",
14056 Alignment);
14057 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
14058 " int const i = 1;\n"
14059 " int * j = 2;\n"
14060 " int big = 10000;\n"
14061 "\n"
14062 " unsigned oneTwoThree = 123;\n"
14063 " int oneTwo = 12;\n"
14064 " method();\n"
14065 " float k = 2;\n"
14066 " int ll = 10000;\n"
14067 "}",
14068 format("void SomeFunction(int parameter= 0) {\n"
14069 " int const i= 1;\n"
14070 " int *j=2;\n"
14071 " int big = 10000;\n"
14072 "\n"
14073 "unsigned oneTwoThree =123;\n"
14074 "int oneTwo = 12;\n"
14075 " method();\n"
14076 "float k= 2;\n"
14077 "int ll=10000;\n"
14078 "}",
14079 Alignment));
14080 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14081 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
14082 verifyFormat("#define A \\\n"
14083 " int aaaa = 12; \\\n"
14084 " float b = 23; \\\n"
14085 " const int ccc = 234; \\\n"
14086 " unsigned dddddddddd = 2345;",
14087 Alignment);
14088 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14089 verifyFormat("#define A \\\n"
14090 " int aaaa = 12; \\\n"
14091 " float b = 23; \\\n"
14092 " const int ccc = 234; \\\n"
14093 " unsigned dddddddddd = 2345;",
14094 Alignment);
14095 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
14096 Alignment.ColumnLimit = 30;
14097 verifyFormat("#define A \\\n"
14098 " int aaaa = 12; \\\n"
14099 " float b = 23; \\\n"
14100 " const int ccc = 234; \\\n"
14101 " int dddddddddd = 2345;",
14102 Alignment);
14103 Alignment.ColumnLimit = 80;
14104 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
14105 "k = 4, int l = 5,\n"
14106 " int m = 6) {\n"
14107 " const int j = 10;\n"
14108 " otherThing = 1;\n"
14109 "}",
14110 Alignment);
14111 verifyFormat("void SomeFunction(int parameter = 0) {\n"
14112 " int const i = 1;\n"
14113 " int * j = 2;\n"
14114 " int big = 10000;\n"
14115 "}",
14116 Alignment);
14117 verifyFormat("class C {\n"
14118 "public:\n"
14119 " int i = 1;\n"
14120 " virtual void f() = 0;\n"
14121 "};",
14122 Alignment);
14123 verifyFormat("float i = 1;\n"
14124 "if (SomeType t = getSomething()) {\n"
14125 "}\n"
14126 "const unsigned j = 2;\n"
14127 "int big = 10000;",
14128 Alignment);
14129 verifyFormat("float j = 7;\n"
14130 "for (int k = 0; k < N; ++k) {\n"
14131 "}\n"
14132 "unsigned j = 2;\n"
14133 "int big = 10000;\n"
14134 "}",
14135 Alignment);
14136 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14137 verifyFormat("float i = 1;\n"
14138 "LooooooooooongType loooooooooooooooooooooongVariable\n"
14139 " = someLooooooooooooooooongFunction();\n"
14140 "int j = 2;",
14141 Alignment);
14142 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
14143 verifyFormat("int i = 1;\n"
14144 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
14145 " someLooooooooooooooooongFunction();\n"
14146 "int j = 2;",
14147 Alignment);
14148
14149 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14150 verifyFormat("auto lambda = []() {\n"
14151 " auto ii = 0;\n"
14152 " float j = 0;\n"
14153 " return 0;\n"
14154 "};\n"
14155 "int i = 0;\n"
14156 "float i2 = 0;\n"
14157 "auto v = type{\n"
14158 " i = 1, //\n"
14159 " (i = 2), //\n"
14160 " i = 3 //\n"
14161 "};",
14162 Alignment);
14163 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14164
14165 verifyFormat(
14166 "int i = 1;\n"
14167 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
14168 " loooooooooooooooooooooongParameterB);\n"
14169 "int j = 2;",
14170 Alignment);
14171
14172 // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
14173 // We expect declarations and assignments to align, as long as it doesn't
14174 // exceed the column limit, starting a new alignment sequence whenever it
14175 // happens.
14176 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14177 Alignment.ColumnLimit = 30;
14178 verifyFormat("float ii = 1;\n"
14179 "unsigned j = 2;\n"
14180 "int someVerylongVariable = 1;\n"
14181 "AnotherLongType ll = 123456;\n"
14182 "VeryVeryLongType k = 2;\n"
14183 "int myvar = 1;",
14184 Alignment);
14185 Alignment.ColumnLimit = 80;
14186 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14187
14188 verifyFormat(
14189 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
14190 " typename LongType, typename B>\n"
14191 "auto foo() {}\n",
14192 Alignment);
14193 verifyFormat("float a, b = 1;\n"
14194 "int c = 2;\n"
14195 "int dd = 3;\n",
14196 Alignment);
14197 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
14198 "float b[1][] = {{3.f}};\n",
14199 Alignment);
14200 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14201 verifyFormat("float a, b = 1;\n"
14202 "int c = 2;\n"
14203 "int dd = 3;\n",
14204 Alignment);
14205 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
14206 "float b[1][] = {{3.f}};\n",
14207 Alignment);
14208 Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14209
14210 Alignment.ColumnLimit = 30;
14211 Alignment.BinPackParameters = false;
14212 verifyFormat("void foo(float a,\n"
14213 " float b,\n"
14214 " int c,\n"
14215 " uint32_t *d) {\n"
14216 " int * e = 0;\n"
14217 " float f = 0;\n"
14218 " double g = 0;\n"
14219 "}\n"
14220 "void bar(ino_t a,\n"
14221 " int b,\n"
14222 " uint32_t *c,\n"
14223 " bool d) {}\n",
14224 Alignment);
14225 Alignment.BinPackParameters = true;
14226 Alignment.ColumnLimit = 80;
14227
14228 // Bug 33507
14229 Alignment.PointerAlignment = FormatStyle::PAS_Middle;
14230 verifyFormat(
14231 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
14232 " static const Version verVs2017;\n"
14233 " return true;\n"
14234 "});\n",
14235 Alignment);
14236 Alignment.PointerAlignment = FormatStyle::PAS_Right;
14237
14238 // See llvm.org/PR35641
14239 Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14240 verifyFormat("int func() { //\n"
14241 " int b;\n"
14242 " unsigned c;\n"
14243 "}",
14244 Alignment);
14245
14246 // See PR37175
14247 FormatStyle Style = getMozillaStyle();
14248 Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14249 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
14250 "foo(int a);",
14251 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
14252}
14253
14254TEST_F(FormatTest, LinuxBraceBreaking) {
14255 FormatStyle LinuxBraceStyle = getLLVMStyle();
14256 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
14257 verifyFormat("namespace a\n"
14258 "{\n"
14259 "class A\n"
14260 "{\n"
14261 " void f()\n"
14262 " {\n"
14263 " if (true) {\n"
14264 " a();\n"
14265 " b();\n"
14266 " } else {\n"
14267 " a();\n"
14268 " }\n"
14269 " }\n"
14270 " void g() { return; }\n"
14271 "};\n"
14272 "struct B {\n"
14273 " int x;\n"
14274 "};\n"
14275 "} // namespace a\n",
14276 LinuxBraceStyle);
14277 verifyFormat("enum X {\n"
14278 " Y = 0,\n"
14279 "}\n",
14280 LinuxBraceStyle);
14281 verifyFormat("struct S {\n"
14282 " int Type;\n"
14283 " union {\n"
14284 " int x;\n"
14285 " double y;\n"
14286 " } Value;\n"
14287 " class C\n"
14288 " {\n"
14289 " MyFavoriteType Value;\n"
14290 " } Class;\n"
14291 "}\n",
14292 LinuxBraceStyle);
14293}
14294
14295TEST_F(FormatTest, MozillaBraceBreaking) {
14296 FormatStyle MozillaBraceStyle = getLLVMStyle();
14297 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
14298 MozillaBraceStyle.FixNamespaceComments = false;
14299 verifyFormat("namespace a {\n"
14300 "class A\n"
14301 "{\n"
14302 " void f()\n"
14303 " {\n"
14304 " if (true) {\n"
14305 " a();\n"
14306 " b();\n"
14307 " }\n"
14308 " }\n"
14309 " void g() { return; }\n"
14310 "};\n"
14311 "enum E\n"
14312 "{\n"
14313 " A,\n"
14314 " // foo\n"
14315 " B,\n"
14316 " C\n"
14317 "};\n"
14318 "struct B\n"
14319 "{\n"
14320 " int x;\n"
14321 "};\n"
14322 "}\n",
14323 MozillaBraceStyle);
14324 verifyFormat("struct S\n"
14325 "{\n"
14326 " int Type;\n"
14327 " union\n"
14328 " {\n"
14329 " int x;\n"
14330 " double y;\n"
14331 " } Value;\n"
14332 " class C\n"
14333 " {\n"
14334 " MyFavoriteType Value;\n"
14335 " } Class;\n"
14336 "}\n",
14337 MozillaBraceStyle);
14338}
14339
14340TEST_F(FormatTest, StroustrupBraceBreaking) {
14341 FormatStyle StroustrupBraceStyle = getLLVMStyle();
14342 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14343 verifyFormat("namespace a {\n"
14344 "class A {\n"
14345 " void f()\n"
14346 " {\n"
14347 " if (true) {\n"
14348 " a();\n"
14349 " b();\n"
14350 " }\n"
14351 " }\n"
14352 " void g() { return; }\n"
14353 "};\n"
14354 "struct B {\n"
14355 " int x;\n"
14356 "};\n"
14357 "} // namespace a\n",
14358 StroustrupBraceStyle);
14359
14360 verifyFormat("void foo()\n"
14361 "{\n"
14362 " if (a) {\n"
14363 " a();\n"
14364 " }\n"
14365 " else {\n"
14366 " b();\n"
14367 " }\n"
14368 "}\n",
14369 StroustrupBraceStyle);
14370
14371 verifyFormat("#ifdef _DEBUG\n"
14372 "int foo(int i = 0)\n"
14373 "#else\n"
14374 "int foo(int i = 5)\n"
14375 "#endif\n"
14376 "{\n"
14377 " return i;\n"
14378 "}",
14379 StroustrupBraceStyle);
14380
14381 verifyFormat("void foo() {}\n"
14382 "void bar()\n"
14383 "#ifdef _DEBUG\n"
14384 "{\n"
14385 " foo();\n"
14386 "}\n"
14387 "#else\n"
14388 "{\n"
14389 "}\n"
14390 "#endif",
14391 StroustrupBraceStyle);
14392
14393 verifyFormat("void foobar() { int i = 5; }\n"
14394 "#ifdef _DEBUG\n"
14395 "void bar() {}\n"
14396 "#else\n"
14397 "void bar() { foobar(); }\n"
14398 "#endif",
14399 StroustrupBraceStyle);
14400}
14401
14402TEST_F(FormatTest, AllmanBraceBreaking) {
14403 FormatStyle AllmanBraceStyle = getLLVMStyle();
14404 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
14405
14406 EXPECT_EQ("namespace a\n"
14407 "{\n"
14408 "void f();\n"
14409 "void g();\n"
14410 "} // namespace a\n",
14411 format("namespace a\n"
14412 "{\n"
14413 "void f();\n"
14414 "void g();\n"
14415 "}\n",
14416 AllmanBraceStyle));
14417
14418 verifyFormat("namespace a\n"
14419 "{\n"
14420 "class A\n"
14421 "{\n"
14422 " void f()\n"
14423 " {\n"
14424 " if (true)\n"
14425 " {\n"
14426 " a();\n"
14427 " b();\n"
14428 " }\n"
14429 " }\n"
14430 " void g() { return; }\n"
14431 "};\n"
14432 "struct B\n"
14433 "{\n"
14434 " int x;\n"
14435 "};\n"
14436 "union C\n"
14437 "{\n"
14438 "};\n"
14439 "} // namespace a",
14440 AllmanBraceStyle);
14441
14442 verifyFormat("void f()\n"
14443 "{\n"
14444 " if (true)\n"
14445 " {\n"
14446 " a();\n"
14447 " }\n"
14448 " else if (false)\n"
14449 " {\n"
14450 " b();\n"
14451 " }\n"
14452 " else\n"
14453 " {\n"
14454 " c();\n"
14455 " }\n"
14456 "}\n",
14457 AllmanBraceStyle);
14458
14459 verifyFormat("void f()\n"
14460 "{\n"
14461 " for (int i = 0; i < 10; ++i)\n"
14462 " {\n"
14463 " a();\n"
14464 " }\n"
14465 " while (false)\n"
14466 " {\n"
14467 " b();\n"
14468 " }\n"
14469 " do\n"
14470 " {\n"
14471 " c();\n"
14472 " } while (false)\n"
14473 "}\n",
14474 AllmanBraceStyle);
14475
14476 verifyFormat("void f(int a)\n"
14477 "{\n"
14478 " switch (a)\n"
14479 " {\n"
14480 " case 0:\n"
14481 " break;\n"
14482 " case 1:\n"
14483 " {\n"
14484 " break;\n"
14485 " }\n"
14486 " case 2:\n"
14487 " {\n"
14488 " }\n"
14489 " break;\n"
14490 " default:\n"
14491 " break;\n"
14492 " }\n"
14493 "}\n",
14494 AllmanBraceStyle);
14495
14496 verifyFormat("enum X\n"
14497 "{\n"
14498 " Y = 0,\n"
14499 "}\n",
14500 AllmanBraceStyle);
14501 verifyFormat("enum X\n"
14502 "{\n"
14503 " Y = 0\n"
14504 "}\n",
14505 AllmanBraceStyle);
14506
14507 verifyFormat("@interface BSApplicationController ()\n"
14508 "{\n"
14509 "@private\n"
14510 " id _extraIvar;\n"
14511 "}\n"
14512 "@end\n",
14513 AllmanBraceStyle);
14514
14515 verifyFormat("#ifdef _DEBUG\n"
14516 "int foo(int i = 0)\n"
14517 "#else\n"
14518 "int foo(int i = 5)\n"
14519 "#endif\n"
14520 "{\n"
14521 " return i;\n"
14522 "}",
14523 AllmanBraceStyle);
14524
14525 verifyFormat("void foo() {}\n"
14526 "void bar()\n"
14527 "#ifdef _DEBUG\n"
14528 "{\n"
14529 " foo();\n"
14530 "}\n"
14531 "#else\n"
14532 "{\n"
14533 "}\n"
14534 "#endif",
14535 AllmanBraceStyle);
14536
14537 verifyFormat("void foobar() { int i = 5; }\n"
14538 "#ifdef _DEBUG\n"
14539 "void bar() {}\n"
14540 "#else\n"
14541 "void bar() { foobar(); }\n"
14542 "#endif",
14543 AllmanBraceStyle);
14544
14545 EXPECT_EQ(AllmanBraceStyle.AllowShortLambdasOnASingleLine,
14546 FormatStyle::SLS_All);
14547
14548 verifyFormat("[](int i) { return i + 2; };\n"
14549 "[](int i, int j)\n"
14550 "{\n"
14551 " auto x = i + j;\n"
14552 " auto y = i * j;\n"
14553 " return x ^ y;\n"
14554 "};\n"
14555 "void foo()\n"
14556 "{\n"
14557 " auto shortLambda = [](int i) { return i + 2; };\n"
14558 " auto longLambda = [](int i, int j)\n"
14559 " {\n"
14560 " auto x = i + j;\n"
14561 " auto y = i * j;\n"
14562 " return x ^ y;\n"
14563 " };\n"
14564 "}",
14565 AllmanBraceStyle);
14566
14567 AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14568
14569 verifyFormat("[](int i)\n"
14570 "{\n"
14571 " return i + 2;\n"
14572 "};\n"
14573 "[](int i, int j)\n"
14574 "{\n"
14575 " auto x = i + j;\n"
14576 " auto y = i * j;\n"
14577 " return x ^ y;\n"
14578 "};\n"
14579 "void foo()\n"
14580 "{\n"
14581 " auto shortLambda = [](int i)\n"
14582 " {\n"
14583 " return i + 2;\n"
14584 " };\n"
14585 " auto longLambda = [](int i, int j)\n"
14586 " {\n"
14587 " auto x = i + j;\n"
14588 " auto y = i * j;\n"
14589 " return x ^ y;\n"
14590 " };\n"
14591 "}",
14592 AllmanBraceStyle);
14593
14594 // Reset
14595 AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
14596
14597 // This shouldn't affect ObjC blocks..
14598 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
14599 " // ...\n"
14600 " int i;\n"
14601 "}];",
14602 AllmanBraceStyle);
14603 verifyFormat("void (^block)(void) = ^{\n"
14604 " // ...\n"
14605 " int i;\n"
14606 "};",
14607 AllmanBraceStyle);
14608 // .. or dict literals.
14609 verifyFormat("void f()\n"
14610 "{\n"
14611 " // ...\n"
14612 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
14613 "}",
14614 AllmanBraceStyle);
14615 verifyFormat("void f()\n"
14616 "{\n"
14617 " // ...\n"
14618 " [object someMethod:@{a : @\"b\"}];\n"
14619 "}",
14620 AllmanBraceStyle);
14621 verifyFormat("int f()\n"
14622 "{ // comment\n"
14623 " return 42;\n"
14624 "}",
14625 AllmanBraceStyle);
14626
14627 AllmanBraceStyle.ColumnLimit = 19;
14628 verifyFormat("void f() { int i; }", AllmanBraceStyle);
14629 AllmanBraceStyle.ColumnLimit = 18;
14630 verifyFormat("void f()\n"
14631 "{\n"
14632 " int i;\n"
14633 "}",
14634 AllmanBraceStyle);
14635 AllmanBraceStyle.ColumnLimit = 80;
14636
14637 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
14638 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
14639 FormatStyle::SIS_WithoutElse;
14640 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
14641 verifyFormat("void f(bool b)\n"
14642 "{\n"
14643 " if (b)\n"
14644 " {\n"
14645 " return;\n"
14646 " }\n"
14647 "}\n",
14648 BreakBeforeBraceShortIfs);
14649 verifyFormat("void f(bool b)\n"
14650 "{\n"
14651 " if constexpr (b)\n"
14652 " {\n"
14653 " return;\n"
14654 " }\n"
14655 "}\n",
14656 BreakBeforeBraceShortIfs);
14657 verifyFormat("void f(bool b)\n"
14658 "{\n"
14659 " if CONSTEXPR (b)\n"
14660 " {\n"
14661 " return;\n"
14662 " }\n"
14663 "}\n",
14664 BreakBeforeBraceShortIfs);
14665 verifyFormat("void f(bool b)\n"
14666 "{\n"
14667 " if (b) return;\n"
14668 "}\n",
14669 BreakBeforeBraceShortIfs);
14670 verifyFormat("void f(bool b)\n"
14671 "{\n"
14672 " if constexpr (b) return;\n"
14673 "}\n",
14674 BreakBeforeBraceShortIfs);
14675 verifyFormat("void f(bool b)\n"
14676 "{\n"
14677 " if CONSTEXPR (b) return;\n"
14678 "}\n",
14679 BreakBeforeBraceShortIfs);
14680 verifyFormat("void f(bool b)\n"
14681 "{\n"
14682 " while (b)\n"
14683 " {\n"
14684 " return;\n"
14685 " }\n"
14686 "}\n",
14687 BreakBeforeBraceShortIfs);
14688}
14689
14690TEST_F(FormatTest, WhitesmithsBraceBreaking) {
14691 FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
14692 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
14693
14694 // Make a few changes to the style for testing purposes
14695 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
14696 FormatStyle::SFS_Empty;
14697 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14698 WhitesmithsBraceStyle.ColumnLimit = 0;
14699
14700 // FIXME: this test case can't decide whether there should be a blank line
14701 // after the ~D() line or not. It adds one if one doesn't exist in the test
14702 // and it removes the line if one exists.
14703 /*
14704 verifyFormat("class A;\n"
14705 "namespace B\n"
14706 " {\n"
14707 "class C;\n"
14708 "// Comment\n"
14709 "class D\n"
14710 " {\n"
14711 "public:\n"
14712 " D();\n"
14713 " ~D() {}\n"
14714 "private:\n"
14715 " enum E\n"
14716 " {\n"
14717 " F\n"
14718 " }\n"
14719 " };\n"
14720 " } // namespace B\n",
14721 WhitesmithsBraceStyle);
14722 */
14723
14724 verifyFormat("namespace a\n"
14725 " {\n"
14726 "class A\n"
14727 " {\n"
14728 " void f()\n"
14729 " {\n"
14730 " if (true)\n"
14731 " {\n"
14732 " a();\n"
14733 " b();\n"
14734 " }\n"
14735 " }\n"
14736 " void g()\n"
14737 " {\n"
14738 " return;\n"
14739 " }\n"
14740 " };\n"
14741 "struct B\n"
14742 " {\n"
14743 " int x;\n"
14744 " };\n"
14745 " } // namespace a",
14746 WhitesmithsBraceStyle);
14747
14748 verifyFormat("void f()\n"
14749 " {\n"
14750 " if (true)\n"
14751 " {\n"
14752 " a();\n"
14753 " }\n"
14754 " else if (false)\n"
14755 " {\n"
14756 " b();\n"
14757 " }\n"
14758 " else\n"
14759 " {\n"
14760 " c();\n"
14761 " }\n"
14762 " }\n",
14763 WhitesmithsBraceStyle);
14764
14765 verifyFormat("void f()\n"
14766 " {\n"
14767 " for (int i = 0; i < 10; ++i)\n"
14768 " {\n"
14769 " a();\n"
14770 " }\n"
14771 " while (false)\n"
14772 " {\n"
14773 " b();\n"
14774 " }\n"
14775 " do\n"
14776 " {\n"
14777 " c();\n"
14778 " } while (false)\n"
14779 " }\n",
14780 WhitesmithsBraceStyle);
14781
14782 WhitesmithsBraceStyle.IndentCaseBlocks = true;
14783 verifyFormat("void switchTest1(int a)\n"
14784 " {\n"
14785 " switch (a)\n"
14786 " {\n"
14787 " case 2:\n"
14788 " {\n"
14789 " }\n"
14790 " break;\n"
14791 " }\n"
14792 " }\n",
14793 WhitesmithsBraceStyle);
14794
14795 verifyFormat("void switchTest2(int a)\n"
14796 " {\n"
14797 " switch (a)\n"
14798 " {\n"
14799 " case 0:\n"
14800 " break;\n"
14801 " case 1:\n"
14802 " {\n"
14803 " break;\n"
14804 " }\n"
14805 " case 2:\n"
14806 " {\n"
14807 " }\n"
14808 " break;\n"
14809 " default:\n"
14810 " break;\n"
14811 " }\n"
14812 " }\n",
14813 WhitesmithsBraceStyle);
14814
14815 verifyFormat("void switchTest3(int a)\n"
14816 " {\n"
14817 " switch (a)\n"
14818 " {\n"
14819 " case 0:\n"
14820 " {\n"
14821 " foo(x);\n"
14822 " }\n"
14823 " break;\n"
14824 " default:\n"
14825 " {\n"
14826 " foo(1);\n"
14827 " }\n"
14828 " break;\n"
14829 " }\n"
14830 " }\n",
14831 WhitesmithsBraceStyle);
14832
14833 WhitesmithsBraceStyle.IndentCaseBlocks = false;
14834
14835 verifyFormat("void switchTest4(int a)\n"
14836 " {\n"
14837 " switch (a)\n"
14838 " {\n"
14839 " case 2:\n"
14840 " {\n"
14841 " }\n"
14842 " break;\n"
14843 " }\n"
14844 " }\n",
14845 WhitesmithsBraceStyle);
14846
14847 verifyFormat("void switchTest5(int a)\n"
14848 " {\n"
14849 " switch (a)\n"
14850 " {\n"
14851 " case 0:\n"
14852 " break;\n"
14853 " case 1:\n"
14854 " {\n"
14855 " foo();\n"
14856 " break;\n"
14857 " }\n"
14858 " case 2:\n"
14859 " {\n"
14860 " }\n"
14861 " break;\n"
14862 " default:\n"
14863 " break;\n"
14864 " }\n"
14865 " }\n",
14866 WhitesmithsBraceStyle);
14867
14868 verifyFormat("void switchTest6(int a)\n"
14869 " {\n"
14870 " switch (a)\n"
14871 " {\n"
14872 " case 0:\n"
14873 " {\n"
14874 " foo(x);\n"
14875 " }\n"
14876 " break;\n"
14877 " default:\n"
14878 " {\n"
14879 " foo(1);\n"
14880 " }\n"
14881 " break;\n"
14882 " }\n"
14883 " }\n",
14884 WhitesmithsBraceStyle);
14885
14886 verifyFormat("enum X\n"
14887 " {\n"
14888 " Y = 0, // testing\n"
14889 " }\n",
14890 WhitesmithsBraceStyle);
14891
14892 verifyFormat("enum X\n"
14893 " {\n"
14894 " Y = 0\n"
14895 " }\n",
14896 WhitesmithsBraceStyle);
14897 verifyFormat("enum X\n"
14898 " {\n"
14899 " Y = 0,\n"
14900 " Z = 1\n"
14901 " };\n",
14902 WhitesmithsBraceStyle);
14903
14904 verifyFormat("@interface BSApplicationController ()\n"
14905 " {\n"
14906 "@private\n"
14907 " id _extraIvar;\n"
14908 " }\n"
14909 "@end\n",
14910 WhitesmithsBraceStyle);
14911
14912 verifyFormat("#ifdef _DEBUG\n"
14913 "int foo(int i = 0)\n"
14914 "#else\n"
14915 "int foo(int i = 5)\n"
14916 "#endif\n"
14917 " {\n"
14918 " return i;\n"
14919 " }",
14920 WhitesmithsBraceStyle);
14921
14922 verifyFormat("void foo() {}\n"
14923 "void bar()\n"
14924 "#ifdef _DEBUG\n"
14925 " {\n"
14926 " foo();\n"
14927 " }\n"
14928 "#else\n"
14929 " {\n"
14930 " }\n"
14931 "#endif",
14932 WhitesmithsBraceStyle);
14933
14934 verifyFormat("void foobar()\n"
14935 " {\n"
14936 " int i = 5;\n"
14937 " }\n"
14938 "#ifdef _DEBUG\n"
14939 "void bar()\n"
14940 " {\n"
14941 " }\n"
14942 "#else\n"
14943 "void bar()\n"
14944 " {\n"
14945 " foobar();\n"
14946 " }\n"
14947 "#endif",
14948 WhitesmithsBraceStyle);
14949
14950 // This shouldn't affect ObjC blocks..
14951 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
14952 " // ...\n"
14953 " int i;\n"
14954 "}];",
14955 WhitesmithsBraceStyle);
14956 verifyFormat("void (^block)(void) = ^{\n"
14957 " // ...\n"
14958 " int i;\n"
14959 "};",
14960 WhitesmithsBraceStyle);
14961 // .. or dict literals.
14962 verifyFormat("void f()\n"
14963 " {\n"
14964 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
14965 " }",
14966 WhitesmithsBraceStyle);
14967
14968 verifyFormat("int f()\n"
14969 " { // comment\n"
14970 " return 42;\n"
14971 " }",
14972 WhitesmithsBraceStyle);
14973
14974 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
14975 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
14976 FormatStyle::SIS_Always;
14977 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
14978 verifyFormat("void f(bool b)\n"
14979 " {\n"
14980 " if (b)\n"
14981 " {\n"
14982 " return;\n"
14983 " }\n"
14984 " }\n",
14985 BreakBeforeBraceShortIfs);
14986 verifyFormat("void f(bool b)\n"
14987 " {\n"
14988 " if (b) return;\n"
14989 " }\n",
14990 BreakBeforeBraceShortIfs);
14991 verifyFormat("void f(bool b)\n"
14992 " {\n"
14993 " while (b)\n"
14994 " {\n"
14995 " return;\n"
14996 " }\n"
14997 " }\n",
14998 BreakBeforeBraceShortIfs);
14999}
15000
15001TEST_F(FormatTest, GNUBraceBreaking) {
15002 FormatStyle GNUBraceStyle = getLLVMStyle();
15003 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
15004 verifyFormat("namespace a\n"
15005 "{\n"
15006 "class A\n"
15007 "{\n"
15008 " void f()\n"
15009 " {\n"
15010 " int a;\n"
15011 " {\n"
15012 " int b;\n"
15013 " }\n"
15014 " if (true)\n"
15015 " {\n"
15016 " a();\n"
15017 " b();\n"
15018 " }\n"
15019 " }\n"
15020 " void g() { return; }\n"
15021 "}\n"
15022 "} // namespace a",
15023 GNUBraceStyle);
15024
15025 verifyFormat("void f()\n"
15026 "{\n"
15027 " if (true)\n"
15028 " {\n"
15029 " a();\n"
15030 " }\n"
15031 " else if (false)\n"
15032 " {\n"
15033 " b();\n"
15034 " }\n"
15035 " else\n"
15036 " {\n"
15037 " c();\n"
15038 " }\n"
15039 "}\n",
15040 GNUBraceStyle);
15041
15042 verifyFormat("void f()\n"
15043 "{\n"
15044 " for (int i = 0; i < 10; ++i)\n"
15045 " {\n"
15046 " a();\n"
15047 " }\n"
15048 " while (false)\n"
15049 " {\n"
15050 " b();\n"
15051 " }\n"
15052 " do\n"
15053 " {\n"
15054 " c();\n"
15055 " }\n"
15056 " while (false);\n"
15057 "}\n",
15058 GNUBraceStyle);
15059
15060 verifyFormat("void f(int a)\n"
15061 "{\n"
15062 " switch (a)\n"
15063 " {\n"
15064 " case 0:\n"
15065 " break;\n"
15066 " case 1:\n"
15067 " {\n"
15068 " break;\n"
15069 " }\n"
15070 " case 2:\n"
15071 " {\n"
15072 " }\n"
15073 " break;\n"
15074 " default:\n"
15075 " break;\n"
15076 " }\n"
15077 "}\n",
15078 GNUBraceStyle);
15079
15080 verifyFormat("enum X\n"
15081 "{\n"
15082 " Y = 0,\n"
15083 "}\n",
15084 GNUBraceStyle);
15085
15086 verifyFormat("@interface BSApplicationController ()\n"
15087 "{\n"
15088 "@private\n"
15089 " id _extraIvar;\n"
15090 "}\n"
15091 "@end\n",
15092 GNUBraceStyle);
15093
15094 verifyFormat("#ifdef _DEBUG\n"
15095 "int foo(int i = 0)\n"
15096 "#else\n"
15097 "int foo(int i = 5)\n"
15098 "#endif\n"
15099 "{\n"
15100 " return i;\n"
15101 "}",
15102 GNUBraceStyle);
15103
15104 verifyFormat("void foo() {}\n"
15105 "void bar()\n"
15106 "#ifdef _DEBUG\n"
15107 "{\n"
15108 " foo();\n"
15109 "}\n"
15110 "#else\n"
15111 "{\n"
15112 "}\n"
15113 "#endif",
15114 GNUBraceStyle);
15115
15116 verifyFormat("void foobar() { int i = 5; }\n"
15117 "#ifdef _DEBUG\n"
15118 "void bar() {}\n"
15119 "#else\n"
15120 "void bar() { foobar(); }\n"
15121 "#endif",
15122 GNUBraceStyle);
15123}
15124
15125TEST_F(FormatTest, WebKitBraceBreaking) {
15126 FormatStyle WebKitBraceStyle = getLLVMStyle();
15127 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
15128 WebKitBraceStyle.FixNamespaceComments = false;
15129 verifyFormat("namespace a {\n"
15130 "class A {\n"
15131 " void f()\n"
15132 " {\n"
15133 " if (true) {\n"
15134 " a();\n"
15135 " b();\n"
15136 " }\n"
15137 " }\n"
15138 " void g() { return; }\n"
15139 "};\n"
15140 "enum E {\n"
15141 " A,\n"
15142 " // foo\n"
15143 " B,\n"
15144 " C\n"
15145 "};\n"
15146 "struct B {\n"
15147 " int x;\n"
15148 "};\n"
15149 "}\n",
15150 WebKitBraceStyle);
15151 verifyFormat("struct S {\n"
15152 " int Type;\n"
15153 " union {\n"
15154 " int x;\n"
15155 " double y;\n"
15156 " } Value;\n"
15157 " class C {\n"
15158 " MyFavoriteType Value;\n"
15159 " } Class;\n"
15160 "};\n",
15161 WebKitBraceStyle);
15162}
15163
15164TEST_F(FormatTest, CatchExceptionReferenceBinding) {
15165 verifyFormat("void f() {\n"
15166 " try {\n"
15167 " } catch (const Exception &e) {\n"
15168 " }\n"
15169 "}\n",
15170 getLLVMStyle());
15171}
15172
15173TEST_F(FormatTest, UnderstandsPragmas) {
15174 verifyFormat("#pragma omp reduction(| : var)");
15175 verifyFormat("#pragma omp reduction(+ : var)");
15176
15177 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
15178 "(including parentheses).",
15179 format("#pragma mark Any non-hyphenated or hyphenated string "
15180 "(including parentheses)."));
15181}
15182
15183TEST_F(FormatTest, UnderstandPragmaOption) {
15184 verifyFormat("#pragma option -C -A");
15185
15186 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));
15187}
15188
15189TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
15190 FormatStyle Style = getLLVMStyle();
15191 Style.ColumnLimit = 20;
15192
15193 // See PR41213
15194 EXPECT_EQ("/*\n"
15195 " *\t9012345\n"
15196 " * /8901\n"
15197 " */",
15198 format("/*\n"
15199 " *\t9012345 /8901\n"
15200 " */",
15201 Style));
15202 EXPECT_EQ("/*\n"
15203 " *345678\n"
15204 " *\t/8901\n"
15205 " */",
15206 format("/*\n"
15207 " *345678\t/8901\n"
15208 " */",
15209 Style));
15210
15211 verifyFormat("int a; // the\n"
15212 " // comment",
15213 Style);
15214 EXPECT_EQ("int a; /* first line\n"
15215 " * second\n"
15216 " * line third\n"
15217 " * line\n"
15218 " */",
15219 format("int a; /* first line\n"
15220 " * second\n"
15221 " * line third\n"
15222 " * line\n"
15223 " */",
15224 Style));
15225 EXPECT_EQ("int a; // first line\n"
15226 " // second\n"
15227 " // line third\n"
15228 " // line",
15229 format("int a; // first line\n"
15230 " // second line\n"
15231 " // third line",
15232 Style));
15233
15234 Style.PenaltyExcessCharacter = 90;
15235 verifyFormat("int a; // the comment", Style);
15236 EXPECT_EQ("int a; // the comment\n"
15237 " // aaa",
15238 format("int a; // the comment aaa", Style));
15239 EXPECT_EQ("int a; /* first line\n"
15240 " * second line\n"
15241 " * third line\n"
15242 " */",
15243 format("int a; /* first line\n"
15244 " * second line\n"
15245 " * third line\n"
15246 " */",
15247 Style));
15248 EXPECT_EQ("int a; // first line\n"
15249 " // second line\n"
15250 " // third line",
15251 format("int a; // first line\n"
15252 " // second line\n"
15253 " // third line",
15254 Style));
15255 // FIXME: Investigate why this is not getting the same layout as the test
15256 // above.
15257 EXPECT_EQ("int a; /* first line\n"
15258 " * second line\n"
15259 " * third line\n"
15260 " */",
15261 format("int a; /* first line second line third line"
15262 "\n*/",
15263 Style));
15264
15265 EXPECT_EQ("// foo bar baz bazfoo\n"
15266 "// foo bar foo bar\n",
15267 format("// foo bar baz bazfoo\n"
15268 "// foo bar foo bar\n",
15269 Style));
15270 EXPECT_EQ("// foo bar baz bazfoo\n"
15271 "// foo bar foo bar\n",
15272 format("// foo bar baz bazfoo\n"
15273 "// foo bar foo bar\n",
15274 Style));
15275
15276 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
15277 // next one.
15278 EXPECT_EQ("// foo bar baz bazfoo\n"
15279 "// bar foo bar\n",
15280 format("// foo bar baz bazfoo bar\n"
15281 "// foo bar\n",
15282 Style));
15283
15284 EXPECT_EQ("// foo bar baz bazfoo\n"
15285 "// foo bar baz bazfoo\n"
15286 "// bar foo bar\n",
15287 format("// foo bar baz bazfoo\n"
15288 "// foo bar baz bazfoo bar\n"
15289 "// foo bar\n",
15290 Style));
15291
15292 EXPECT_EQ("// foo bar baz bazfoo\n"
15293 "// foo bar baz bazfoo\n"
15294 "// bar foo bar\n",
15295 format("// foo bar baz bazfoo\n"
15296 "// foo bar baz bazfoo bar\n"
15297 "// foo bar\n",
15298 Style));
15299
15300 // Make sure we do not keep protruding characters if strict mode reflow is
15301 // cheaper than keeping protruding characters.
15302 Style.ColumnLimit = 21;
15303 EXPECT_EQ(
15304 "// foo foo foo foo\n"
15305 "// foo foo foo foo\n"
15306 "// foo foo foo foo\n",
15307 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
15308
15309 EXPECT_EQ("int a = /* long block\n"
15310 " comment */\n"
15311 " 42;",
15312 format("int a = /* long block comment */ 42;", Style));
15313}
15314
15315#define EXPECT_ALL_STYLES_EQUAL(Styles) \
15316 for (size_t i = 1; i < Styles.size(); ++i) \
15317 EXPECT_EQ(Styles[0], Styles[i]) \
15318 << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
15319
15320TEST_F(FormatTest, GetsPredefinedStyleByName) {
15321 SmallVector<FormatStyle, 3> Styles;
15322 Styles.resize(3);
15323
15324 Styles[0] = getLLVMStyle();
15325 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
15326 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
15327 EXPECT_ALL_STYLES_EQUAL(Styles);
15328
15329 Styles[0] = getGoogleStyle();
15330 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
15331 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
15332 EXPECT_ALL_STYLES_EQUAL(Styles);
15333
15334 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
15335 EXPECT_TRUE(
15336 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
15337 EXPECT_TRUE(
15338 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
15339 EXPECT_ALL_STYLES_EQUAL(Styles);
15340
15341 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
15342 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
15343 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
15344 EXPECT_ALL_STYLES_EQUAL(Styles);
15345
15346 Styles[0] = getMozillaStyle();
15347 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
15348 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
15349 EXPECT_ALL_STYLES_EQUAL(Styles);
15350
15351 Styles[0] = getWebKitStyle();
15352 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
15353 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
15354 EXPECT_ALL_STYLES_EQUAL(Styles);
15355
15356 Styles[0] = getGNUStyle();
15357 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
15358 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
15359 EXPECT_ALL_STYLES_EQUAL(Styles);
15360
15361 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
15362}
15363
15364TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
15365 SmallVector<FormatStyle, 8> Styles;
15366 Styles.resize(2);
15367
15368 Styles[0] = getGoogleStyle();
15369 Styles[1] = getLLVMStyle();
15370 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
15371 EXPECT_ALL_STYLES_EQUAL(Styles);
15372
15373 Styles.resize(5);
15374 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
15375 Styles[1] = getLLVMStyle();
15376 Styles[1].Language = FormatStyle::LK_JavaScript;
15377 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
15378
15379 Styles[2] = getLLVMStyle();
15380 Styles[2].Language = FormatStyle::LK_JavaScript;
15381 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
15382 "BasedOnStyle: Google",
15383 &Styles[2])
15384 .value());
15385
15386 Styles[3] = getLLVMStyle();
15387 Styles[3].Language = FormatStyle::LK_JavaScript;
15388 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
15389 "Language: JavaScript",
15390 &Styles[3])
15391 .value());
15392
15393 Styles[4] = getLLVMStyle();
15394 Styles[4].Language = FormatStyle::LK_JavaScript;
15395 EXPECT_EQ(0, parseConfiguration("---\n"
15396 "BasedOnStyle: LLVM\n"
15397 "IndentWidth: 123\n"
15398 "---\n"
15399 "BasedOnStyle: Google\n"
15400 "Language: JavaScript",
15401 &Styles[4])
15402 .value());
15403 EXPECT_ALL_STYLES_EQUAL(Styles);
15404}
15405
15406#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
15407 Style.FIELD = false; \
15408 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
15409 EXPECT_TRUE(Style.FIELD); \
15410 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
15411 EXPECT_FALSE(Style.FIELD);
15412
15413#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
15414
15415#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
15416 Style.STRUCT.FIELD = false; \
15417 EXPECT_EQ(0, \
15418 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
15419 .value()); \
15420 EXPECT_TRUE(Style.STRUCT.FIELD); \
15421 EXPECT_EQ(0, \
15422 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
15423 .value()); \
15424 EXPECT_FALSE(Style.STRUCT.FIELD);
15425
15426#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
15427 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
15428
15429#define CHECK_PARSE(TEXT, FIELD, VALUE) \
15430 EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!"; \
15431 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
15432 EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
15433
15434TEST_F(FormatTest, ParsesConfigurationBools) {
15435 FormatStyle Style = {};
15436 Style.Language = FormatStyle::LK_Cpp;
15437 CHECK_PARSE_BOOL(AlignTrailingComments);
15438 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
15439 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
15440 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
15441 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
15442 CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
15443 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
15444 CHECK_PARSE_BOOL(BinPackArguments);
15445 CHECK_PARSE_BOOL(BinPackParameters);
15446 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
15447 CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
15448 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
15449 CHECK_PARSE_BOOL(BreakStringLiterals);
15450 CHECK_PARSE_BOOL(CompactNamespaces);
15451 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
15452 CHECK_PARSE_BOOL(DeriveLineEnding);
15453 CHECK_PARSE_BOOL(DerivePointerAlignment);
15454 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
15455 CHECK_PARSE_BOOL(DisableFormat);
15456 CHECK_PARSE_BOOL(IndentCaseLabels);
15457 CHECK_PARSE_BOOL(IndentCaseBlocks);
15458 CHECK_PARSE_BOOL(IndentGotoLabels);
15459 CHECK_PARSE_BOOL(IndentRequires);
15460 CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
15461 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
15462 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
15463 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
15464 CHECK_PARSE_BOOL(Cpp11BracedListStyle);
15465 CHECK_PARSE_BOOL(ReflowComments);
15466 CHECK_PARSE_BOOL(SortIncludes);
15467 CHECK_PARSE_BOOL(SortUsingDeclarations);
15468 CHECK_PARSE_BOOL(SpacesInParentheses);
15469 CHECK_PARSE_BOOL(SpacesInSquareBrackets);
15470 CHECK_PARSE_BOOL(SpacesInAngles);
15471 CHECK_PARSE_BOOL(SpacesInConditionalStatement);
15472 CHECK_PARSE_BOOL(SpaceInEmptyBlock);
15473 CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
15474 CHECK_PARSE_BOOL(SpacesInContainerLiterals);
15475 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
15476 CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
15477 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
15478 CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
15479 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
15480 CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
15481 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
15482 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
15483 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
15484 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
15485 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
15486 CHECK_PARSE_BOOL(UseCRLF);
15487
15488 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
15489 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
15490 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
15491 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
15492 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
15493 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
15494 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
15495 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
15496 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
15497 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
15498 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
15499 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
15500 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
15501 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
15502 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
15503 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
15504 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
15505}
15506
15507#undef CHECK_PARSE_BOOL
15508
15509TEST_F(FormatTest, ParsesConfiguration) {
15510 FormatStyle Style = {};
15511 Style.Language = FormatStyle::LK_Cpp;
15512 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
15513 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
15514 ConstructorInitializerIndentWidth, 1234u);
15515 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
15516 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
15517 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
15518 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
15519 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
15520 PenaltyBreakBeforeFirstCallParameter, 1234u);
15521 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
15522 PenaltyBreakTemplateDeclaration, 1234u);
15523 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
15524 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
15525 PenaltyReturnTypeOnItsOwnLine, 1234u);
15526 CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
15527 SpacesBeforeTrailingComments, 1234u);
15528 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
15529 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
15530 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
15531
15532 Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
15533 CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments,
15534 FormatStyle::ACS_None);
15535 CHECK_PARSE("AlignConsecutiveAssignments: Consecutive",
15536 AlignConsecutiveAssignments, FormatStyle::ACS_Consecutive);
15537 CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLines",
15538 AlignConsecutiveAssignments, FormatStyle::ACS_AcrossEmptyLines);
15539 CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLinesAndComments",
15540 AlignConsecutiveAssignments,
15541 FormatStyle::ACS_AcrossEmptyLinesAndComments);
15542 // For backwards compability, false / true should still parse
15543 CHECK_PARSE("AlignConsecutiveAssignments: false", AlignConsecutiveAssignments,
15544 FormatStyle::ACS_None);
15545 CHECK_PARSE("AlignConsecutiveAssignments: true", AlignConsecutiveAssignments,
15546 FormatStyle::ACS_Consecutive);
15547
15548 Style.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
15549 CHECK_PARSE("AlignConsecutiveBitFields: None", AlignConsecutiveBitFields,
15550 FormatStyle::ACS_None);
15551 CHECK_PARSE("AlignConsecutiveBitFields: Consecutive",
15552 AlignConsecutiveBitFields, FormatStyle::ACS_Consecutive);
15553 CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLines",
15554 AlignConsecutiveBitFields, FormatStyle::ACS_AcrossEmptyLines);
15555 CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLinesAndComments",
15556 AlignConsecutiveBitFields,
15557 FormatStyle::ACS_AcrossEmptyLinesAndComments);
15558 // For backwards compability, false / true should still parse
15559 CHECK_PARSE("AlignConsecutiveBitFields: false", AlignConsecutiveBitFields,
15560 FormatStyle::ACS_None);
15561 CHECK_PARSE("AlignConsecutiveBitFields: true", AlignConsecutiveBitFields,
15562 FormatStyle::ACS_Consecutive);
15563
15564 Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15565 CHECK_PARSE("AlignConsecutiveMacros: None", AlignConsecutiveMacros,
15566 FormatStyle::ACS_None);
15567 CHECK_PARSE("AlignConsecutiveMacros: Consecutive", AlignConsecutiveMacros,
15568 FormatStyle::ACS_Consecutive);
15569 CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLines",
15570 AlignConsecutiveMacros, FormatStyle::ACS_AcrossEmptyLines);
15571 CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLinesAndComments",
15572 AlignConsecutiveMacros,
15573 FormatStyle::ACS_AcrossEmptyLinesAndComments);
15574 // For backwards compability, false / true should still parse
15575 CHECK_PARSE("AlignConsecutiveMacros: false", AlignConsecutiveMacros,
15576 FormatStyle::ACS_None);
15577 CHECK_PARSE("AlignConsecutiveMacros: true", AlignConsecutiveMacros,
15578 FormatStyle::ACS_Consecutive);
15579
15580 Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
15581 CHECK_PARSE("AlignConsecutiveDeclarations: None",
15582 AlignConsecutiveDeclarations, FormatStyle::ACS_None);
15583 CHECK_PARSE("AlignConsecutiveDeclarations: Consecutive",
15584 AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
15585 CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLines",
15586 AlignConsecutiveDeclarations, FormatStyle::ACS_AcrossEmptyLines);
15587 CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLinesAndComments",
15588 AlignConsecutiveDeclarations,
15589 FormatStyle::ACS_AcrossEmptyLinesAndComments);
15590 // For backwards compability, false / true should still parse
15591 CHECK_PARSE("AlignConsecutiveDeclarations: false",
15592 AlignConsecutiveDeclarations, FormatStyle::ACS_None);
15593 CHECK_PARSE("AlignConsecutiveDeclarations: true",
15594 AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
15595
15596 Style.PointerAlignment = FormatStyle::PAS_Middle;
15597 CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
15598 FormatStyle::PAS_Left);
15599 CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
15600 FormatStyle::PAS_Right);
15601 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
15602 FormatStyle::PAS_Middle);
15603 // For backward compatibility:
15604 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
15605 FormatStyle::PAS_Left);
15606 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
15607 FormatStyle::PAS_Right);
15608 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
15609 FormatStyle::PAS_Middle);
15610
15611 Style.Standard = FormatStyle::LS_Auto;
15612 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
15613 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
15614 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
15615 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
15616 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
15617 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
15618 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
15619 // Legacy aliases:
15620 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
15621 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
15622 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
15623 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
15624
15625 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
15626 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
15627 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
15628 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
15629 FormatStyle::BOS_None);
15630 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
15631 FormatStyle::BOS_All);
15632 // For backward compatibility:
15633 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
15634 FormatStyle::BOS_None);
15635 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
15636 FormatStyle::BOS_All);
15637
15638 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
15639 CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
15640 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
15641 CHECK_PARSE("BreakConstructorInitializers: AfterColon",
15642 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
15643 CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
15644 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
15645 // For backward compatibility:
15646 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
15647 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
15648
15649 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
15650 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
15651 FormatStyle::BILS_BeforeComma);
15652 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
15653 FormatStyle::BILS_AfterColon);
15654 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
15655 FormatStyle::BILS_BeforeColon);
15656 // For backward compatibility:
15657 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
15658 FormatStyle::BILS_BeforeComma);
15659
15660 Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
15661 CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
15662 EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
15663 CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
15664 EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
15665 CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
15666 EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
15667 CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
15668 EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
15669
15670 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
15671 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
15672 FormatStyle::BAS_Align);
15673 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
15674 FormatStyle::BAS_DontAlign);
15675 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
15676 FormatStyle::BAS_AlwaysBreak);
15677 // For backward compatibility:
15678 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
15679 FormatStyle::BAS_DontAlign);
15680 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
15681 FormatStyle::BAS_Align);
15682
15683 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
15684 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
15685 FormatStyle::ENAS_DontAlign);
15686 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
15687 FormatStyle::ENAS_Left);
15688 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
15689 FormatStyle::ENAS_Right);
15690 // For backward compatibility:
15691 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
15692 FormatStyle::ENAS_Left);
15693 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
15694 FormatStyle::ENAS_Right);
15695
15696 Style.AlignOperands = FormatStyle::OAS_Align;
15697 CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
15698 FormatStyle::OAS_DontAlign);
15699 CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
15700 CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
15701 FormatStyle::OAS_AlignAfterOperator);
15702 // For backward compatibility:
15703 CHECK_PARSE("AlignOperands: false", AlignOperands,
15704 FormatStyle::OAS_DontAlign);
15705 CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
15706
15707 Style.UseTab = FormatStyle::UT_ForIndentation;
15708 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
15709 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
15710 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
15711 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
15712 FormatStyle::UT_ForContinuationAndIndentation);
15713 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
15714 FormatStyle::UT_AlignWithSpaces);
15715 // For backward compatibility:
15716 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
15717 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
15718
15719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
15720 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
15721 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
15722 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
15723 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
15724 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
15725 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
15726 // For backward compatibility:
15727 CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
15728 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
15729 CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
15730 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
15731
15732 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
15733 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
15734 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
15735 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
15736 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
15737 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
15738 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
15739 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
15740 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
15741 // For backward compatibility:
15742 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
15743 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
15744 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
15745 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
15746
15747 Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
15748 CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
15749 SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
15750 CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
15751 SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
15752 CHECK_PARSE("SpaceAroundPointerQualifiers: After",
15753 SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
15754 CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
15755 SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
15756
15757 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
15758 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
15759 FormatStyle::SBPO_Never);
15760 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
15761 FormatStyle::SBPO_Always);
15762 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
15763 FormatStyle::SBPO_ControlStatements);
15764 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
15765 FormatStyle::SBPO_NonEmptyParentheses);
15766 // For backward compatibility:
15767 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
15768 FormatStyle::SBPO_Never);
15769 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
15770 FormatStyle::SBPO_ControlStatements);
15771
15772 Style.ColumnLimit = 123;
15773 FormatStyle BaseStyle = getLLVMStyle();
15774 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
15775 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
15776
15777 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
15778 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
15779 FormatStyle::BS_Attach);
15780 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
15781 FormatStyle::BS_Linux);
15782 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
15783 FormatStyle::BS_Mozilla);
15784 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
15785 FormatStyle::BS_Stroustrup);
15786 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
15787 FormatStyle::BS_Allman);
15788 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
15789 FormatStyle::BS_Whitesmiths);
15790 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
15791 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
15792 FormatStyle::BS_WebKit);
15793 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
15794 FormatStyle::BS_Custom);
15795
15796 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
15797 CHECK_PARSE("BraceWrapping:\n"
15798 " AfterControlStatement: MultiLine",
15799 BraceWrapping.AfterControlStatement,
15800 FormatStyle::BWACS_MultiLine);
15801 CHECK_PARSE("BraceWrapping:\n"
15802 " AfterControlStatement: Always",
15803 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
15804 CHECK_PARSE("BraceWrapping:\n"
15805 " AfterControlStatement: Never",
15806 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
15807 // For backward compatibility:
15808 CHECK_PARSE("BraceWrapping:\n"
15809 " AfterControlStatement: true",
15810 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
15811 CHECK_PARSE("BraceWrapping:\n"
15812 " AfterControlStatement: false",
15813 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
15814
15815 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
15816 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
15817 FormatStyle::RTBS_None);
15818 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
15819 FormatStyle::RTBS_All);
15820 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
15821 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
15822 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
15823 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
15824 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
15825 AlwaysBreakAfterReturnType,
15826 FormatStyle::RTBS_TopLevelDefinitions);
15827
15828 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
15829 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
15830 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
15831 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
15832 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
15833 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
15834 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
15835 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
15836 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
15837 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
15838 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
15839
15840 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
15841 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
15842 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
15843 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
15844 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
15845 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
15846 AlwaysBreakAfterDefinitionReturnType,
15847 FormatStyle::DRTBS_TopLevel);
15848
15849 Style.NamespaceIndentation = FormatStyle::NI_All;
15850 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
15851 FormatStyle::NI_None);
15852 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
15853 FormatStyle::NI_Inner);
15854 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
15855 FormatStyle::NI_All);
15856
15857 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
15858 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
15859 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
15860 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
15861 AllowShortIfStatementsOnASingleLine,
15862 FormatStyle::SIS_WithoutElse);
15863 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
15864 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
15865 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
15866 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
15867 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
15868 AllowShortIfStatementsOnASingleLine,
15869 FormatStyle::SIS_WithoutElse);
15870
15871 Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
15872 CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
15873 FormatStyle::IEBS_AfterExternBlock);
15874 CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
15875 FormatStyle::IEBS_Indent);
15876 CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
15877 FormatStyle::IEBS_NoIndent);
15878 CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
15879 FormatStyle::IEBS_Indent);
15880 CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
15881 FormatStyle::IEBS_NoIndent);
15882
15883 Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
15884 CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
15885 FormatStyle::BFCS_Both);
15886 CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
15887 FormatStyle::BFCS_None);
15888 CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
15889 FormatStyle::BFCS_Before);
15890 CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
15891 FormatStyle::BFCS_After);
15892
15893 Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
15894 CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
15895 FormatStyle::SJSIO_After);
15896 CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
15897 FormatStyle::SJSIO_Before);
15898
15899 // FIXME: This is required because parsing a configuration simply overwrites
15900 // the first N elements of the list instead of resetting it.
15901 Style.ForEachMacros.clear();
15902 std::vector<std::string> BoostForeach;
15903 BoostForeach.push_back("BOOST_FOREACH");
15904 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
15905 std::vector<std::string> BoostAndQForeach;
15906 BoostAndQForeach.push_back("BOOST_FOREACH");
15907 BoostAndQForeach.push_back("Q_FOREACH");
15908 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
15909 BoostAndQForeach);
15910
15911 Style.AttributeMacros.clear();
15912 CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
15913 std::vector<std::string>{"__capability"});
15914 CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
15915 std::vector<std::string>({"attr1", "attr2"}));
15916
15917 Style.StatementAttributeLikeMacros.clear();
15918 CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
15919 StatementAttributeLikeMacros,
15920 std::vector<std::string>({"emit", "Q_EMIT"}));
15921
15922 Style.StatementMacros.clear();
15923 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
15924 std::vector<std::string>{"QUNUSED"});
15925 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
15926 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
15927
15928 Style.NamespaceMacros.clear();
15929 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
15930 std::vector<std::string>{"TESTSUITE"});
15931 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
15932 std::vector<std::string>({"TESTSUITE", "SUITE"}));
15933
15934 Style.WhitespaceSensitiveMacros.clear();
15935 CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
15936 WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
15937 CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
15938 WhitespaceSensitiveMacros,
15939 std::vector<std::string>({"STRINGIZE", "ASSERT"}));
15940 Style.WhitespaceSensitiveMacros.clear();
15941 CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
15942 WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
15943 CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
15944 WhitespaceSensitiveMacros,
15945 std::vector<std::string>({"STRINGIZE", "ASSERT"}));
15946
15947 Style.IncludeStyle.IncludeCategories.clear();
15948 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
15949 {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
15950 CHECK_PARSE("IncludeCategories:\n"
15951 " - Regex: abc/.*\n"
15952 " Priority: 2\n"
15953 " - Regex: .*\n"
15954 " Priority: 1\n"
15955 " CaseSensitive: true\n",
15956 IncludeStyle.IncludeCategories, ExpectedCategories);
15957 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
15958 "abc$");
15959 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
15960 IncludeStyle.IncludeIsMainSourceRegex, "abc$");
15961
15962 Style.RawStringFormats.clear();
15963 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
15964 {
15965 FormatStyle::LK_TextProto,
15966 {"pb", "proto"},
15967 {"PARSE_TEXT_PROTO"},
15968 /*CanonicalDelimiter=*/"",
15969 "llvm",
15970 },
15971 {
15972 FormatStyle::LK_Cpp,
15973 {"cc", "cpp"},
15974 {"C_CODEBLOCK", "CPPEVAL"},
15975 /*CanonicalDelimiter=*/"cc",
15976 /*BasedOnStyle=*/"",
15977 },
15978 };
15979
15980 CHECK_PARSE("RawStringFormats:\n"
15981 " - Language: TextProto\n"
15982 " Delimiters:\n"
15983 " - 'pb'\n"
15984 " - 'proto'\n"
15985 " EnclosingFunctions:\n"
15986 " - 'PARSE_TEXT_PROTO'\n"
15987 " BasedOnStyle: llvm\n"
15988 " - Language: Cpp\n"
15989 " Delimiters:\n"
15990 " - 'cc'\n"
15991 " - 'cpp'\n"
15992 " EnclosingFunctions:\n"
15993 " - 'C_CODEBLOCK'\n"
15994 " - 'CPPEVAL'\n"
15995 " CanonicalDelimiter: 'cc'",
15996 RawStringFormats, ExpectedRawStringFormats);
15997}
15998
15999TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
16000 FormatStyle Style = {};
16001 Style.Language = FormatStyle::LK_Cpp;
16002 CHECK_PARSE("Language: Cpp\n"
16003 "IndentWidth: 12",
16004 IndentWidth, 12u);
16005 EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
16006 "IndentWidth: 34",
16007 &Style),
16008 ParseError::Unsuitable);
16009 FormatStyle BinPackedTCS = {};
16010 BinPackedTCS.Language = FormatStyle::LK_JavaScript;
16011 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
16012 "InsertTrailingCommas: Wrapped",
16013 &BinPackedTCS),
16014 ParseError::BinPackTrailingCommaConflict);
16015 EXPECT_EQ(12u, Style.IndentWidth);
16016 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
16017 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
16018
16019 Style.Language = FormatStyle::LK_JavaScript;
16020 CHECK_PARSE("Language: JavaScript\n"
16021 "IndentWidth: 12",
16022 IndentWidth, 12u);
16023 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
16024 EXPECT_EQ(parseConfiguration("Language: Cpp\n"
16025 "IndentWidth: 34",
16026 &Style),
16027 ParseError::Unsuitable);
16028 EXPECT_EQ(23u, Style.IndentWidth);
16029 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
16030 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
16031
16032 CHECK_PARSE("BasedOnStyle: LLVM\n"
16033 "IndentWidth: 67",
16034 IndentWidth, 67u);
16035
16036 CHECK_PARSE("---\n"
16037 "Language: JavaScript\n"
16038 "IndentWidth: 12\n"
16039 "---\n"
16040 "Language: Cpp\n"
16041 "IndentWidth: 34\n"
16042 "...\n",
16043 IndentWidth, 12u);
16044
16045 Style.Language = FormatStyle::LK_Cpp;
16046 CHECK_PARSE("---\n"
16047 "Language: JavaScript\n"
16048 "IndentWidth: 12\n"
16049 "---\n"
16050 "Language: Cpp\n"
16051 "IndentWidth: 34\n"
16052 "...\n",
16053 IndentWidth, 34u);
16054 CHECK_PARSE("---\n"
16055 "IndentWidth: 78\n"
16056 "---\n"
16057 "Language: JavaScript\n"
16058 "IndentWidth: 56\n"
16059 "...\n",
16060 IndentWidth, 78u);
16061
16062 Style.ColumnLimit = 123;
16063 Style.IndentWidth = 234;
16064 Style.BreakBeforeBraces = FormatStyle::BS_Linux;
16065 Style.TabWidth = 345;
16066 EXPECT_FALSE(parseConfiguration("---\n"
16067 "IndentWidth: 456\n"
16068 "BreakBeforeBraces: Allman\n"
16069 "---\n"
16070 "Language: JavaScript\n"
16071 "IndentWidth: 111\n"
16072 "TabWidth: 111\n"
16073 "---\n"
16074 "Language: Cpp\n"
16075 "BreakBeforeBraces: Stroustrup\n"
16076 "TabWidth: 789\n"
16077 "...\n",
16078 &Style));
16079 EXPECT_EQ(123u, Style.ColumnLimit);
16080 EXPECT_EQ(456u, Style.IndentWidth);
16081 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
16082 EXPECT_EQ(789u, Style.TabWidth);
16083
16084 EXPECT_EQ(parseConfiguration("---\n"
16085 "Language: JavaScript\n"
16086 "IndentWidth: 56\n"
16087 "---\n"
16088 "IndentWidth: 78\n"
16089 "...\n",
16090 &Style),
16091 ParseError::Error);
16092 EXPECT_EQ(parseConfiguration("---\n"
16093 "Language: JavaScript\n"
16094 "IndentWidth: 56\n"
16095 "---\n"
16096 "Language: JavaScript\n"
16097 "IndentWidth: 78\n"
16098 "...\n",
16099 &Style),
16100 ParseError::Error);
16101
16102 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
16103}
16104
16105#undef CHECK_PARSE
16106
16107TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
16108 FormatStyle Style = {};
16109 Style.Language = FormatStyle::LK_JavaScript;
16110 Style.BreakBeforeTernaryOperators = true;
16111 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
16112 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
16113
16114 Style.BreakBeforeTernaryOperators = true;
16115 EXPECT_EQ(0, parseConfiguration("---\n"
16116 "BasedOnStyle: Google\n"
16117 "---\n"
16118 "Language: JavaScript\n"
16119 "IndentWidth: 76\n"
16120 "...\n",
16121 &Style)
16122 .value());
16123 EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
16124 EXPECT_EQ(76u, Style.IndentWidth);
16125 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
16126}
16127
16128TEST_F(FormatTest, ConfigurationRoundTripTest) {
16129 FormatStyle Style = getLLVMStyle();
16130 std::string YAML = configurationAsText(Style);
16131 FormatStyle ParsedStyle = {};
16132 ParsedStyle.Language = FormatStyle::LK_Cpp;
16133 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
16134 EXPECT_EQ(Style, ParsedStyle);
16135}
16136
16137TEST_F(FormatTest, WorksFor8bitEncodings) {
16138 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
16139 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
16140 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
16141 "\"\xef\xee\xf0\xf3...\"",
16142 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
16143 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
16144 "\xef\xee\xf0\xf3...\"",
16145 getLLVMStyleWithColumns(12)));
16146}
16147
16148TEST_F(FormatTest, HandlesUTF8BOM) {
16149 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
16150 EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
16151 format("\xef\xbb\xbf#include <iostream>"));
16152 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
16153 format("\xef\xbb\xbf\n#include <iostream>"));
16154}
16155
16156// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
16157#if !defined(_MSC_VER)
16158
16159TEST_F(FormatTest, CountsUTF8CharactersProperly) {
16160 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
16161 getLLVMStyleWithColumns(35));
16162 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
16163 getLLVMStyleWithColumns(31));
16164 verifyFormat("// Однажды в студёную зимнюю пору...",
16165 getLLVMStyleWithColumns(36));
16166 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
16167 verifyFormat("/* Однажды в студёную зимнюю пору... */",
16168 getLLVMStyleWithColumns(39));
16169 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
16170 getLLVMStyleWithColumns(35));
16171}
16172
16173TEST_F(FormatTest, SplitsUTF8Strings) {
16174 // Non-printable characters' width is currently considered to be the length in
16175 // bytes in UTF8. The characters can be displayed in very different manner
16176 // (zero-width, single width with a substitution glyph, expanded to their code
16177 // (e.g. "<8d>"), so there's no single correct way to handle them.
16178 EXPECT_EQ("\"aaaaÄ\"\n"
16179 "\"\xc2\x8d\";",
16180 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
16181 EXPECT_EQ("\"aaaaaaaÄ\"\n"
16182 "\"\xc2\x8d\";",
16183 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
16184 EXPECT_EQ("\"Однажды, в \"\n"
16185 "\"студёную \"\n"
16186 "\"зимнюю \"\n"
16187 "\"пору,\"",
16188 format("\"Однажды, в студёную зимнюю пору,\"",
16189 getLLVMStyleWithColumns(13)));
16190 EXPECT_EQ(
16191 "\"一 二 三 \"\n"
16192 "\"四 五六 \"\n"
16193 "\"七 八 九 \"\n"
16194 "\"十\"",
16195 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
16196 EXPECT_EQ("\"一\t\"\n"
16197 "\"二 \t\"\n"
16198 "\"三 四 \"\n"
16199 "\"五\t\"\n"
16200 "\"六 \t\"\n"
16201 "\"七 \"\n"
16202 "\"八九十\tqq\"",
16203 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
16204 getLLVMStyleWithColumns(11)));
16205
16206 // UTF8 character in an escape sequence.
16207 EXPECT_EQ("\"aaaaaa\"\n"
16208 "\"\\\xC2\x8D\"",
16209 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
16210}
16211
16212TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
16213 EXPECT_EQ("const char *sssss =\n"
16214 " \"一二三四五六七八\\\n"
16215 " 九 十\";",
16216 format("const char *sssss = \"一二三四五六七八\\\n"
16217 " 九 十\";",
16218 getLLVMStyleWithColumns(30)));
16219}
16220
16221TEST_F(FormatTest, SplitsUTF8LineComments) {
16222 EXPECT_EQ("// aaaaÄ\xc2\x8d",
16223 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
16224 EXPECT_EQ("// Я из лесу\n"
16225 "// вышел; был\n"
16226 "// сильный\n"
16227 "// мороз.",
16228 format("// Я из лесу вышел; был сильный мороз.",
16229 getLLVMStyleWithColumns(13)));
16230 EXPECT_EQ("// 一二三\n"
16231 "// 四五六七\n"
16232 "// 八 九\n"
16233 "// 十",
16234 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9)));
16235}
16236
16237TEST_F(FormatTest, SplitsUTF8BlockComments) {
16238 EXPECT_EQ("/* Гляжу,\n"
16239 " * поднимается\n"
16240 " * медленно в\n"
16241 " * гору\n"
16242 " * Лошадка,\n"
16243 " * везущая\n"
16244 " * хворосту\n"
16245 " * воз. */",
16246 format("/* Гляжу, поднимается медленно в гору\n"
16247 " * Лошадка, везущая хворосту воз. */",
16248 getLLVMStyleWithColumns(13)));
16249 EXPECT_EQ(
16250 "/* 一二三\n"
16251 " * 四五六七\n"
16252 " * 八 九\n"
16253 " * 十 */",
16254 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
16255 EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
16256 " * 𝕓𝕪𝕥𝕖\n"
16257 " * 𝖀𝕿𝕱-𝟠 */",
16258 format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
16259}
16260
16261#endif // _MSC_VER
16262
16263TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
16264 FormatStyle Style = getLLVMStyle();
16265
16266 Style.ConstructorInitializerIndentWidth = 4;
16267 verifyFormat(
16268 "SomeClass::Constructor()\n"
16269 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16270 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16271 Style);
16272
16273 Style.ConstructorInitializerIndentWidth = 2;
16274 verifyFormat(
16275 "SomeClass::Constructor()\n"
16276 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16277 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16278 Style);
16279
16280 Style.ConstructorInitializerIndentWidth = 0;
16281 verifyFormat(
16282 "SomeClass::Constructor()\n"
16283 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16284 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16285 Style);
16286 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
16287 verifyFormat(
16288 "SomeLongTemplateVariableName<\n"
16289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
16290 Style);
16291 verifyFormat("bool smaller = 1 < "
16292 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
16293 " "
16294 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
16295 Style);
16296
16297 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
16298 verifyFormat("SomeClass::Constructor() :\n"
16299 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
16300 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
16301 Style);
16302}
16303
16304TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
16305 FormatStyle Style = getLLVMStyle();
16306 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
16307 Style.ConstructorInitializerIndentWidth = 4;
16308 verifyFormat("SomeClass::Constructor()\n"
16309 " : a(a)\n"
16310 " , b(b)\n"
16311 " , c(c) {}",
16312 Style);
16313 verifyFormat("SomeClass::Constructor()\n"
16314 " : a(a) {}",
16315 Style);
16316
16317 Style.ColumnLimit = 0;
16318 verifyFormat("SomeClass::Constructor()\n"
16319 " : a(a) {}",
16320 Style);
16321 verifyFormat("SomeClass::Constructor() noexcept\n"
16322 " : a(a) {}",
16323 Style);
16324 verifyFormat("SomeClass::Constructor()\n"
16325 " : a(a)\n"
16326 " , b(b)\n"
16327 " , c(c) {}",
16328 Style);
16329 verifyFormat("SomeClass::Constructor()\n"
16330 " : a(a) {\n"
16331 " foo();\n"
16332 " bar();\n"
16333 "}",
16334 Style);
16335
16336 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
16337 verifyFormat("SomeClass::Constructor()\n"
16338 " : a(a)\n"
16339 " , b(b)\n"
16340 " , c(c) {\n}",
16341 Style);
16342 verifyFormat("SomeClass::Constructor()\n"
16343 " : a(a) {\n}",
16344 Style);
16345
16346 Style.ColumnLimit = 80;
16347 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
16348 Style.ConstructorInitializerIndentWidth = 2;
16349 verifyFormat("SomeClass::Constructor()\n"
16350 " : a(a)\n"
16351 " , b(b)\n"
16352 " , c(c) {}",
16353 Style);
16354
16355 Style.ConstructorInitializerIndentWidth = 0;
16356 verifyFormat("SomeClass::Constructor()\n"
16357 ": a(a)\n"
16358 ", b(b)\n"
16359 ", c(c) {}",
16360 Style);
16361
16362 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
16363 Style.ConstructorInitializerIndentWidth = 4;
16364 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
16365 verifyFormat(
16366 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
16367 Style);
16368 verifyFormat(
16369 "SomeClass::Constructor()\n"
16370 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
16371 Style);
16372 Style.ConstructorInitializerIndentWidth = 4;
16373 Style.ColumnLimit = 60;
16374 verifyFormat("SomeClass::Constructor()\n"
16375 " : aaaaaaaa(aaaaaaaa)\n"
16376 " , aaaaaaaa(aaaaaaaa)\n"
16377 " , aaaaaaaa(aaaaaaaa) {}",
16378 Style);
16379}
16380
16381TEST_F(FormatTest, Destructors) {
16382 verifyFormat("void F(int &i) { i.~int(); }");
16383 verifyFormat("void F(int &i) { i->~int(); }");
16384}
16385
16386TEST_F(FormatTest, FormatsWithWebKitStyle) {
16387 FormatStyle Style = getWebKitStyle();
16388
16389 // Don't indent in outer namespaces.
16390 verifyFormat("namespace outer {\n"
16391 "int i;\n"
16392 "namespace inner {\n"
16393 " int i;\n"
16394 "} // namespace inner\n"
16395 "} // namespace outer\n"
16396 "namespace other_outer {\n"
16397 "int i;\n"
16398 "}",
16399 Style);
16400
16401 // Don't indent case labels.
16402 verifyFormat("switch (variable) {\n"
16403 "case 1:\n"
16404 "case 2:\n"
16405 " doSomething();\n"
16406 " break;\n"
16407 "default:\n"
16408 " ++variable;\n"
16409 "}",
16410 Style);
16411
16412 // Wrap before binary operators.
16413 EXPECT_EQ("void f()\n"
16414 "{\n"
16415 " if (aaaaaaaaaaaaaaaa\n"
16416 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
16417 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
16418 " return;\n"
16419 "}",
16420 format("void f() {\n"
16421 "if (aaaaaaaaaaaaaaaa\n"
16422 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
16423 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
16424 "return;\n"
16425 "}",
16426 Style));
16427
16428 // Allow functions on a single line.
16429 verifyFormat("void f() { return; }", Style);
16430
16431 // Allow empty blocks on a single line and insert a space in empty blocks.
16432 EXPECT_EQ("void f() { }", format("void f() {}", Style));
16433 EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
16434 // However, don't merge non-empty short loops.
16435 EXPECT_EQ("while (true) {\n"
16436 " continue;\n"
16437 "}",
16438 format("while (true) { continue; }", Style));
16439
16440 // Constructor initializers are formatted one per line with the "," on the
16441 // new line.
16442 verifyFormat("Constructor()\n"
16443 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
16444 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
16445 " aaaaaaaaaaaaaa)\n"
16446 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
16447 "{\n"
16448 "}",
16449 Style);
16450 verifyFormat("SomeClass::Constructor()\n"
16451 " : a(a)\n"
16452 "{\n"
16453 "}",
16454 Style);
16455 EXPECT_EQ("SomeClass::Constructor()\n"
16456 " : a(a)\n"
16457 "{\n"
16458 "}",
16459 format("SomeClass::Constructor():a(a){}", Style));
16460 verifyFormat("SomeClass::Constructor()\n"
16461 " : a(a)\n"
16462 " , b(b)\n"
16463 " , c(c)\n"
16464 "{\n"
16465 "}",
16466 Style);
16467 verifyFormat("SomeClass::Constructor()\n"
16468 " : a(a)\n"
16469 "{\n"
16470 " foo();\n"
16471 " bar();\n"
16472 "}",
16473 Style);
16474
16475 // Access specifiers should be aligned left.
16476 verifyFormat("class C {\n"
16477 "public:\n"
16478 " int i;\n"
16479 "};",
16480 Style);
16481
16482 // Do not align comments.
16483 verifyFormat("int a; // Do not\n"
16484 "double b; // align comments.",
16485 Style);
16486
16487 // Do not align operands.
16488 EXPECT_EQ("ASSERT(aaaa\n"
16489 " || bbbb);",
16490 format("ASSERT ( aaaa\n||bbbb);", Style));
16491
16492 // Accept input's line breaks.
16493 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
16494 " || bbbbbbbbbbbbbbb) {\n"
16495 " i++;\n"
16496 "}",
16497 format("if (aaaaaaaaaaaaaaa\n"
16498 "|| bbbbbbbbbbbbbbb) { i++; }",
16499 Style));
16500 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
16501 " i++;\n"
16502 "}",
16503 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
16504
16505 // Don't automatically break all macro definitions (llvm.org/PR17842).
16506 verifyFormat("#define aNumber 10", Style);
16507 // However, generally keep the line breaks that the user authored.
16508 EXPECT_EQ("#define aNumber \\\n"
16509 " 10",
16510 format("#define aNumber \\\n"
16511 " 10",
16512 Style));
16513
16514 // Keep empty and one-element array literals on a single line.
16515 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
16516 " copyItems:YES];",
16517 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
16518 "copyItems:YES];",
16519 Style));
16520 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
16521 " copyItems:YES];",
16522 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
16523 " copyItems:YES];",
16524 Style));
16525 // FIXME: This does not seem right, there should be more indentation before
16526 // the array literal's entries. Nested blocks have the same problem.
16527 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
16528 " @\"a\",\n"
16529 " @\"a\"\n"
16530 "]\n"
16531 " copyItems:YES];",
16532 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
16533 " @\"a\",\n"
16534 " @\"a\"\n"
16535 " ]\n"
16536 " copyItems:YES];",
16537 Style));
16538 EXPECT_EQ(
16539 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
16540 " copyItems:YES];",
16541 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
16542 " copyItems:YES];",
16543 Style));
16544
16545 verifyFormat("[self.a b:c c:d];", Style);
16546 EXPECT_EQ("[self.a b:c\n"
16547 " c:d];",
16548 format("[self.a b:c\n"
16549 "c:d];",
16550 Style));
16551}
16552
16553TEST_F(FormatTest, FormatsLambdas) {
16554 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
16555 verifyFormat(
16556 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
16557 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
16558 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
16559 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
16560 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
16561 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
16562 verifyFormat("auto c = [a = [b = 42] {}] {};\n");
16563 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
16564 verifyFormat("int x = f(*+[] {});");
16565 verifyFormat("void f() {\n"
16566 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
16567 "}\n");
16568 verifyFormat("void f() {\n"
16569 " other(x.begin(), //\n"
16570 " x.end(), //\n"
16571 " [&](int, int) { return 1; });\n"
16572 "}\n");
16573 verifyFormat("void f() {\n"
16574 " other.other.other.other.other(\n"
16575 " x.begin(), x.end(),\n"
16576 " [something, rather](int, int, int, int, int, int, int) { "
16577 "return 1; });\n"
16578 "}\n");
16579 verifyFormat(
16580 "void f() {\n"
16581 " other.other.other.other.other(\n"
16582 " x.begin(), x.end(),\n"
16583 " [something, rather](int, int, int, int, int, int, int) {\n"
16584 " //\n"
16585 " });\n"
16586 "}\n");
16587 verifyFormat("SomeFunction([]() { // A cool function...\n"
16588 " return 43;\n"
16589 "});");
16590 EXPECT_EQ("SomeFunction([]() {\n"
16591 "#define A a\n"
16592 " return 43;\n"
16593 "});",
16594 format("SomeFunction([](){\n"
16595 "#define A a\n"
16596 "return 43;\n"
16597 "});"));
16598 verifyFormat("void f() {\n"
16599 " SomeFunction([](decltype(x), A *a) {});\n"
16600 " SomeFunction([](typeof(x), A *a) {});\n"
16601 " SomeFunction([](_Atomic(x), A *a) {});\n"
16602 " SomeFunction([](__underlying_type(x), A *a) {});\n"
16603 "}");
16604 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
16605 " [](const aaaaaaaaaa &a) { return a; });");
16606 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
16607 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
16608 "});");
16609 verifyFormat("Constructor()\n"
16610 " : Field([] { // comment\n"
16611 " int i;\n"
16612 " }) {}");
16613 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
16614 " return some_parameter.size();\n"
16615 "};");
16616 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
16617 " [](const string &s) { return s; };");
16618 verifyFormat("int i = aaaaaa ? 1 //\n"
16619 " : [] {\n"
16620 " return 2; //\n"
16621 " }();");
16622 verifyFormat("llvm::errs() << \"number of twos is \"\n"
16623 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
16624 " return x == 2; // force break\n"
16625 " });");
16626 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
16627 " [=](int iiiiiiiiiiii) {\n"
16628 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
16629 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
16630 " });",
16631 getLLVMStyleWithColumns(60));
16632 verifyFormat("SomeFunction({[&] {\n"
16633 " // comment\n"
16634 " },\n"
16635 " [&] {\n"
16636 " // comment\n"
16637 " }});");
16638 verifyFormat("SomeFunction({[&] {\n"
16639 " // comment\n"
16640 "}});");
16641 verifyFormat(
16642 "virtual aaaaaaaaaaaaaaaa(\n"
16643 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
16644 " aaaaa aaaaaaaaa);");
16645
16646 // Lambdas with return types.
16647 verifyFormat("int c = []() -> int { return 2; }();\n");
16648 verifyFormat("int c = []() -> int * { return 2; }();\n");
16649 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
16650 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
16651 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
16652 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
16653 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
16654 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
16655 verifyFormat("[a, a]() -> a<1> {};");
16656 verifyFormat("[]() -> foo<5 + 2> { return {}; };");
16657 verifyFormat("[]() -> foo<5 - 2> { return {}; };");
16658 verifyFormat("[]() -> foo<5 / 2> { return {}; };");
16659 verifyFormat("[]() -> foo<5 * 2> { return {}; };");
16660 verifyFormat("[]() -> foo<5 % 2> { return {}; };");
16661 verifyFormat("[]() -> foo<5 << 2> { return {}; };");
16662 verifyFormat("[]() -> foo<!5> { return {}; };");
16663 verifyFormat("[]() -> foo<~5> { return {}; };");
16664 verifyFormat("[]() -> foo<5 | 2> { return {}; };");
16665 verifyFormat("[]() -> foo<5 || 2> { return {}; };");
16666 verifyFormat("[]() -> foo<5 & 2> { return {}; };");
16667 verifyFormat("[]() -> foo<5 && 2> { return {}; };");
16668 verifyFormat("[]() -> foo<5 == 2> { return {}; };");
16669 verifyFormat("[]() -> foo<5 != 2> { return {}; };");
16670 verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
16671 verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
16672 verifyFormat("[]() -> foo<5 < 2> { return {}; };");
16673 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
16674 verifyFormat("namespace bar {\n"
16675 "// broken:\n"
16676 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
16677 "} // namespace bar");
16678 verifyFormat("namespace bar {\n"
16679 "// broken:\n"
16680 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
16681 "} // namespace bar");
16682 verifyFormat("namespace bar {\n"
16683 "// broken:\n"
16684 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
16685 "} // namespace bar");
16686 verifyFormat("namespace bar {\n"
16687 "// broken:\n"
16688 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
16689 "} // namespace bar");
16690 verifyFormat("namespace bar {\n"
16691 "// broken:\n"
16692 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
16693 "} // namespace bar");
16694 verifyFormat("namespace bar {\n"
16695 "// broken:\n"
16696 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
16697 "} // namespace bar");
16698 verifyFormat("namespace bar {\n"
16699 "// broken:\n"
16700 "auto foo{[]() -> foo<!5> { return {}; }};\n"
16701 "} // namespace bar");
16702 verifyFormat("namespace bar {\n"
16703 "// broken:\n"
16704 "auto foo{[]() -> foo<~5> { return {}; }};\n"
16705 "} // namespace bar");
16706 verifyFormat("namespace bar {\n"
16707 "// broken:\n"
16708 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
16709 "} // namespace bar");
16710 verifyFormat("namespace bar {\n"
16711 "// broken:\n"
16712 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
16713 "} // namespace bar");
16714 verifyFormat("namespace bar {\n"
16715 "// broken:\n"
16716 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
16717 "} // namespace bar");
16718 verifyFormat("namespace bar {\n"
16719 "// broken:\n"
16720 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
16721 "} // namespace bar");
16722 verifyFormat("namespace bar {\n"
16723 "// broken:\n"
16724 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
16725 "} // namespace bar");
16726 verifyFormat("namespace bar {\n"
16727 "// broken:\n"
16728 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
16729 "} // namespace bar");
16730 verifyFormat("namespace bar {\n"
16731 "// broken:\n"
16732 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
16733 "} // namespace bar");
16734 verifyFormat("namespace bar {\n"
16735 "// broken:\n"
16736 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
16737 "} // namespace bar");
16738 verifyFormat("namespace bar {\n"
16739 "// broken:\n"
16740 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
16741 "} // namespace bar");
16742 verifyFormat("namespace bar {\n"
16743 "// broken:\n"
16744 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
16745 "} // namespace bar");
16746 verifyFormat("[]() -> a<1> {};");
16747 verifyFormat("[]() -> a<1> { ; };");
16748 verifyFormat("[]() -> a<1> { ; }();");
16749 verifyFormat("[a, a]() -> a<true> {};");
16750 verifyFormat("[]() -> a<true> {};");
16751 verifyFormat("[]() -> a<true> { ; };");
16752 verifyFormat("[]() -> a<true> { ; }();");
16753 verifyFormat("[a, a]() -> a<false> {};");
16754 verifyFormat("[]() -> a<false> {};");
16755 verifyFormat("[]() -> a<false> { ; };");
16756 verifyFormat("[]() -> a<false> { ; }();");
16757 verifyFormat("auto foo{[]() -> foo<false> { ; }};");
16758 verifyFormat("namespace bar {\n"
16759 "auto foo{[]() -> foo<false> { ; }};\n"
16760 "} // namespace bar");
16761 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
16762 " int j) -> int {\n"
16763 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
16764 "};");
16765 verifyFormat(
16766 "aaaaaaaaaaaaaaaaaaaaaa(\n"
16767 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
16768 " return aaaaaaaaaaaaaaaaa;\n"
16769 " });",
16770 getLLVMStyleWithColumns(70));
16771 verifyFormat("[]() //\n"
16772 " -> int {\n"
16773 " return 1; //\n"
16774 "};");
16775 verifyFormat("[]() -> Void<T...> {};");
16776 verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
16777
16778 // Lambdas with explicit template argument lists.
16779 verifyFormat(
16780 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
16781
16782 // Multiple lambdas in the same parentheses change indentation rules. These
16783 // lambdas are forced to start on new lines.
16784 verifyFormat("SomeFunction(\n"
16785 " []() {\n"
16786 " //\n"
16787 " },\n"
16788 " []() {\n"
16789 " //\n"
16790 " });");
16791
16792 // A lambda passed as arg0 is always pushed to the next line.
16793 verifyFormat("SomeFunction(\n"
16794 " [this] {\n"
16795 " //\n"
16796 " },\n"
16797 " 1);\n");
16798
16799 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
16800 // the arg0 case above.
16801 auto Style = getGoogleStyle();
16802 Style.BinPackArguments = false;
16803 verifyFormat("SomeFunction(\n"
16804 " a,\n"
16805 " [this] {\n"
16806 " //\n"
16807 " },\n"
16808 " b);\n",
16809 Style);
16810 verifyFormat("SomeFunction(\n"
16811 " a,\n"
16812 " [this] {\n"
16813 " //\n"
16814 " },\n"
16815 " b);\n");
16816
16817 // A lambda with a very long line forces arg0 to be pushed out irrespective of
16818 // the BinPackArguments value (as long as the code is wide enough).
16819 verifyFormat(
16820 "something->SomeFunction(\n"
16821 " a,\n"
16822 " [this] {\n"
16823 " "
16824 "D0000000000000000000000000000000000000000000000000000000000001();\n"
16825 " },\n"
16826 " b);\n");
16827
16828 // A multi-line lambda is pulled up as long as the introducer fits on the
16829 // previous line and there are no further args.
16830 verifyFormat("function(1, [this, that] {\n"
16831 " //\n"
16832 "});\n");
16833 verifyFormat("function([this, that] {\n"
16834 " //\n"
16835 "});\n");
16836 // FIXME: this format is not ideal and we should consider forcing the first
16837 // arg onto its own line.
16838 verifyFormat("function(a, b, c, //\n"
16839 " d, [this, that] {\n"
16840 " //\n"
16841 " });\n");
16842
16843 // Multiple lambdas are treated correctly even when there is a short arg0.
16844 verifyFormat("SomeFunction(\n"
16845 " 1,\n"
16846 " [this] {\n"
16847 " //\n"
16848 " },\n"
16849 " [this] {\n"
16850 " //\n"
16851 " },\n"
16852 " 1);\n");
16853
16854 // More complex introducers.
16855 verifyFormat("return [i, args...] {};");
16856
16857 // Not lambdas.
16858 verifyFormat("constexpr char hello[]{\"hello\"};");
16859 verifyFormat("double &operator[](int i) { return 0; }\n"
16860 "int i;");
16861 verifyFormat("std::unique_ptr<int[]> foo() {}");
16862 verifyFormat("int i = a[a][a]->f();");
16863 verifyFormat("int i = (*b)[a]->f();");
16864
16865 // Other corner cases.
16866 verifyFormat("void f() {\n"
16867 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
16868 " );\n"
16869 "}");
16870
16871 // Lambdas created through weird macros.
16872 verifyFormat("void f() {\n"
16873 " MACRO((const AA &a) { return 1; });\n"
16874 " MACRO((AA &a) { return 1; });\n"
16875 "}");
16876
16877 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
16878 " doo_dah();\n"
16879 " doo_dah();\n"
16880 " })) {\n"
16881 "}");
16882 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
16883 " doo_dah();\n"
16884 " doo_dah();\n"
16885 " })) {\n"
16886 "}");
16887 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
16888 " doo_dah();\n"
16889 " doo_dah();\n"
16890 " })) {\n"
16891 "}");
16892 verifyFormat("auto lambda = []() {\n"
16893 " int a = 2\n"
16894 "#if A\n"
16895 " + 2\n"
16896 "#endif\n"
16897 " ;\n"
16898 "};");
16899
16900 // Lambdas with complex multiline introducers.
16901 verifyFormat(
16902 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
16903 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
16904 " -> ::std::unordered_set<\n"
16905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
16906 " //\n"
16907 " });");
16908
16909 FormatStyle DoNotMerge = getLLVMStyle();
16910 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
16911 verifyFormat("auto c = []() {\n"
16912 " return b;\n"
16913 "};",
16914 "auto c = []() { return b; };", DoNotMerge);
16915 verifyFormat("auto c = []() {\n"
16916 "};",
16917 " auto c = []() {};", DoNotMerge);
16918
16919 FormatStyle MergeEmptyOnly = getLLVMStyle();
16920 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
16921 verifyFormat("auto c = []() {\n"
16922 " return b;\n"
16923 "};",
16924 "auto c = []() {\n"
16925 " return b;\n"
16926 " };",
16927 MergeEmptyOnly);
16928 verifyFormat("auto c = []() {};",
16929 "auto c = []() {\n"
16930 "};",
16931 MergeEmptyOnly);
16932
16933 FormatStyle MergeInline = getLLVMStyle();
16934 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
16935 verifyFormat("auto c = []() {\n"
16936 " return b;\n"
16937 "};",
16938 "auto c = []() { return b; };", MergeInline);
16939 verifyFormat("function([]() { return b; })", "function([]() { return b; })",
16940 MergeInline);
16941 verifyFormat("function([]() { return b; }, a)",
16942 "function([]() { return b; }, a)", MergeInline);
16943 verifyFormat("function(a, []() { return b; })",
16944 "function(a, []() { return b; })", MergeInline);
16945
16946 // Check option "BraceWrapping.BeforeLambdaBody" and different state of
16947 // AllowShortLambdasOnASingleLine
16948 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
16949 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
16950 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
16951 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
16952 FormatStyle::ShortLambdaStyle::SLS_None;
16953 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
16954 " []()\n"
16955 " {\n"
16956 " return 17;\n"
16957 " });",
16958 LLVMWithBeforeLambdaBody);
16959 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
16960 " []()\n"
16961 " {\n"
16962 " });",
16963 LLVMWithBeforeLambdaBody);
16964 verifyFormat("auto fct_SLS_None = []()\n"
16965 "{\n"
16966 " return 17;\n"
16967 "};",
16968 LLVMWithBeforeLambdaBody);
16969 verifyFormat("TwoNestedLambdas_SLS_None(\n"
16970 " []()\n"
16971 " {\n"
16972 " return Call(\n"
16973 " []()\n"
16974 " {\n"
16975 " return 17;\n"
16976 " });\n"
16977 " });",
16978 LLVMWithBeforeLambdaBody);
16979 verifyFormat("void Fct()\n"
16980 "{\n"
16981 " return {[]()\n"
16982 " {\n"
16983 " return 17;\n"
16984 " }};\n"
16985 "}",
16986 LLVMWithBeforeLambdaBody);
16987
16988 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
16989 FormatStyle::ShortLambdaStyle::SLS_Empty;
16990 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
16991 " []()\n"
16992 " {\n"
16993 " return 17;\n"
16994 " });",
16995 LLVMWithBeforeLambdaBody);
16996 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
16997 LLVMWithBeforeLambdaBody);
16998 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
16999 "ongFunctionName_SLS_Empty(\n"
17000 " []() {});",
17001 LLVMWithBeforeLambdaBody);
17002 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
17003 " []()\n"
17004 " {\n"
17005 " return 17;\n"
17006 " });",
17007 LLVMWithBeforeLambdaBody);
17008 verifyFormat("auto fct_SLS_Empty = []()\n"
17009 "{\n"
17010 " return 17;\n"
17011 "};",
17012 LLVMWithBeforeLambdaBody);
17013 verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
17014 " []()\n"
17015 " {\n"
17016 " return Call([]() {});\n"
17017 " });",
17018 LLVMWithBeforeLambdaBody);
17019 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
17020 " []()\n"
17021 " {\n"
17022 " return Call([]() {});\n"
17023 " });",
17024 LLVMWithBeforeLambdaBody);
17025 verifyFormat(
17026 "FctWithLongLineInLambda_SLS_Empty(\n"
17027 " []()\n"
17028 " {\n"
17029 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17030 " AndShouldNotBeConsiderAsInline,\n"
17031 " LambdaBodyMustBeBreak);\n"
17032 " });",
17033 LLVMWithBeforeLambdaBody);
17034
17035 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17036 FormatStyle::ShortLambdaStyle::SLS_Inline;
17037 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
17038 LLVMWithBeforeLambdaBody);
17039 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
17040 LLVMWithBeforeLambdaBody);
17041 verifyFormat("auto fct_SLS_Inline = []()\n"
17042 "{\n"
17043 " return 17;\n"
17044 "};",
17045 LLVMWithBeforeLambdaBody);
17046 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
17047 "17; }); });",
17048 LLVMWithBeforeLambdaBody);
17049 verifyFormat(
17050 "FctWithLongLineInLambda_SLS_Inline(\n"
17051 " []()\n"
17052 " {\n"
17053 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17054 " AndShouldNotBeConsiderAsInline,\n"
17055 " LambdaBodyMustBeBreak);\n"
17056 " });",
17057 LLVMWithBeforeLambdaBody);
17058 verifyFormat("FctWithMultipleParams_SLS_Inline("
17059 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
17060 " []() { return 17; });",
17061 LLVMWithBeforeLambdaBody);
17062 verifyFormat(
17063 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
17064 LLVMWithBeforeLambdaBody);
17065
17066 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17067 FormatStyle::ShortLambdaStyle::SLS_All;
17068 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
17069 LLVMWithBeforeLambdaBody);
17070 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
17071 LLVMWithBeforeLambdaBody);
17072 verifyFormat("auto fct_SLS_All = []() { return 17; };",
17073 LLVMWithBeforeLambdaBody);
17074 verifyFormat("FctWithOneParam_SLS_All(\n"
17075 " []()\n"
17076 " {\n"
17077 " // A cool function...\n"
17078 " return 43;\n"
17079 " });",
17080 LLVMWithBeforeLambdaBody);
17081 verifyFormat("FctWithMultipleParams_SLS_All("
17082 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
17083 " []() { return 17; });",
17084 LLVMWithBeforeLambdaBody);
17085 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
17086 LLVMWithBeforeLambdaBody);
17087 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
17088 LLVMWithBeforeLambdaBody);
17089 verifyFormat(
17090 "FctWithLongLineInLambda_SLS_All(\n"
17091 " []()\n"
17092 " {\n"
17093 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17094 " AndShouldNotBeConsiderAsInline,\n"
17095 " LambdaBodyMustBeBreak);\n"
17096 " });",
17097 LLVMWithBeforeLambdaBody);
17098 verifyFormat(
17099 "auto fct_SLS_All = []()\n"
17100 "{\n"
17101 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17102 " AndShouldNotBeConsiderAsInline,\n"
17103 " LambdaBodyMustBeBreak);\n"
17104 "};",
17105 LLVMWithBeforeLambdaBody);
17106 LLVMWithBeforeLambdaBody.BinPackParameters = false;
17107 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
17108 LLVMWithBeforeLambdaBody);
17109 verifyFormat(
17110 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
17111 " FirstParam,\n"
17112 " SecondParam,\n"
17113 " ThirdParam,\n"
17114 " FourthParam);",
17115 LLVMWithBeforeLambdaBody);
17116 verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
17117 " []() { return "
17118 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
17119 " FirstParam,\n"
17120 " SecondParam,\n"
17121 " ThirdParam,\n"
17122 " FourthParam);",
17123 LLVMWithBeforeLambdaBody);
17124 verifyFormat(
17125 "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
17126 " SecondParam,\n"
17127 " ThirdParam,\n"
17128 " FourthParam,\n"
17129 " []() { return SomeValueNotSoLong; });",
17130 LLVMWithBeforeLambdaBody);
17131 verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
17132 " []()\n"
17133 " {\n"
17134 " return "
17135 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
17136 "eConsiderAsInline;\n"
17137 " });",
17138 LLVMWithBeforeLambdaBody);
17139 verifyFormat(
17140 "FctWithLongLineInLambda_SLS_All(\n"
17141 " []()\n"
17142 " {\n"
17143 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17144 " AndShouldNotBeConsiderAsInline,\n"
17145 " LambdaBodyMustBeBreak);\n"
17146 " });",
17147 LLVMWithBeforeLambdaBody);
17148 verifyFormat("FctWithTwoParams_SLS_All(\n"
17149 " []()\n"
17150 " {\n"
17151 " // A cool function...\n"
17152 " return 43;\n"
17153 " },\n"
17154 " 87);",
17155 LLVMWithBeforeLambdaBody);
17156 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
17157 LLVMWithBeforeLambdaBody);
17158 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
17159 LLVMWithBeforeLambdaBody);
17160 verifyFormat(
17161 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
17162 LLVMWithBeforeLambdaBody);
17163 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
17164 "}); }, x);",
17165 LLVMWithBeforeLambdaBody);
17166 verifyFormat("TwoNestedLambdas_SLS_All(\n"
17167 " []()\n"
17168 " {\n"
17169 " // A cool function...\n"
17170 " return Call([]() { return 17; });\n"
17171 " });",
17172 LLVMWithBeforeLambdaBody);
17173 verifyFormat("TwoNestedLambdas_SLS_All(\n"
17174 " []()\n"
17175 " {\n"
17176 " return Call(\n"
17177 " []()\n"
17178 " {\n"
17179 " // A cool function...\n"
17180 " return 17;\n"
17181 " });\n"
17182 " });",
17183 LLVMWithBeforeLambdaBody);
17184}
17185
17186TEST_F(FormatTest, LambdaWithLineComments) {
17187 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
17188 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
17189 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
17190 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17191 FormatStyle::ShortLambdaStyle::SLS_All;
17192
17193 verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
17194 verifyFormat("auto k = []() // comment\n"
17195 "{ return; }",
17196 LLVMWithBeforeLambdaBody);
17197 verifyFormat("auto k = []() /* comment */ { return; }",
17198 LLVMWithBeforeLambdaBody);
17199 verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
17200 LLVMWithBeforeLambdaBody);
17201 verifyFormat("auto k = []() // X\n"
17202 "{ return; }",
17203 LLVMWithBeforeLambdaBody);
17204 verifyFormat(
17205 "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
17206 "{ return; }",
17207 LLVMWithBeforeLambdaBody);
17208}
17209
17210TEST_F(FormatTest, EmptyLinesInLambdas) {
17211 verifyFormat("auto lambda = []() {\n"
17212 " x(); //\n"
17213 "};",
17214 "auto lambda = []() {\n"
17215 "\n"
17216 " x(); //\n"
17217 "\n"
17218 "};");
17219}
17220
17221TEST_F(FormatTest, FormatsBlocks) {
17222 FormatStyle ShortBlocks = getLLVMStyle();
17223 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
17224 verifyFormat("int (^Block)(int, int);", ShortBlocks);
17225 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
17226 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
17227 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
17228 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
17229 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
17230
17231 verifyFormat("foo(^{ bar(); });", ShortBlocks);
17232 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
17233 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
17234
17235 verifyFormat("[operation setCompletionBlock:^{\n"
17236 " [self onOperationDone];\n"
17237 "}];");
17238 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
17239 " [self onOperationDone];\n"
17240 "}]};");
17241 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
17242 " f();\n"
17243 "}];");
17244 verifyFormat("int a = [operation block:^int(int *i) {\n"
17245 " return 1;\n"
17246 "}];");
17247 verifyFormat("[myObject doSomethingWith:arg1\n"
17248 " aaa:^int(int *a) {\n"
17249 " return 1;\n"
17250 " }\n"
17251 " bbb:f(a * bbbbbbbb)];");
17252
17253 verifyFormat("[operation setCompletionBlock:^{\n"
17254 " [self.delegate newDataAvailable];\n"
17255 "}];",
17256 getLLVMStyleWithColumns(60));
17257 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
17258 " NSString *path = [self sessionFilePath];\n"
17259 " if (path) {\n"
17260 " // ...\n"
17261 " }\n"
17262 "});");
17263 verifyFormat("[[SessionService sharedService]\n"
17264 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17265 " if (window) {\n"
17266 " [self windowDidLoad:window];\n"
17267 " } else {\n"
17268 " [self errorLoadingWindow];\n"
17269 " }\n"
17270 " }];");
17271 verifyFormat("void (^largeBlock)(void) = ^{\n"
17272 " // ...\n"
17273 "};\n",
17274 getLLVMStyleWithColumns(40));
17275 verifyFormat("[[SessionService sharedService]\n"
17276 " loadWindowWithCompletionBlock: //\n"
17277 " ^(SessionWindow *window) {\n"
17278 " if (window) {\n"
17279 " [self windowDidLoad:window];\n"
17280 " } else {\n"
17281 " [self errorLoadingWindow];\n"
17282 " }\n"
17283 " }];",
17284 getLLVMStyleWithColumns(60));
17285 verifyFormat("[myObject doSomethingWith:arg1\n"
17286 " firstBlock:^(Foo *a) {\n"
17287 " // ...\n"
17288 " int i;\n"
17289 " }\n"
17290 " secondBlock:^(Bar *b) {\n"
17291 " // ...\n"
17292 " int i;\n"
17293 " }\n"
17294 " thirdBlock:^Foo(Bar *b) {\n"
17295 " // ...\n"
17296 " int i;\n"
17297 " }];");
17298 verifyFormat("[myObject doSomethingWith:arg1\n"
17299 " firstBlock:-1\n"
17300 " secondBlock:^(Bar *b) {\n"
17301 " // ...\n"
17302 " int i;\n"
17303 " }];");
17304
17305 verifyFormat("f(^{\n"
17306 " @autoreleasepool {\n"
17307 " if (a) {\n"
17308 " g();\n"
17309 " }\n"
17310 " }\n"
17311 "});");
17312 verifyFormat("Block b = ^int *(A *a, B *b) {}");
17313 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
17314 "};");
17315
17316 FormatStyle FourIndent = getLLVMStyle();
17317 FourIndent.ObjCBlockIndentWidth = 4;
17318 verifyFormat("[operation setCompletionBlock:^{\n"
17319 " [self onOperationDone];\n"
17320 "}];",
17321 FourIndent);
17322}
17323
17324TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
17325 FormatStyle ZeroColumn = getLLVMStyle();
17326 ZeroColumn.ColumnLimit = 0;
17327
17328 verifyFormat("[[SessionService sharedService] "
17329 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17330 " if (window) {\n"
17331 " [self windowDidLoad:window];\n"
17332 " } else {\n"
17333 " [self errorLoadingWindow];\n"
17334 " }\n"
17335 "}];",
17336 ZeroColumn);
17337 EXPECT_EQ("[[SessionService sharedService]\n"
17338 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17339 " if (window) {\n"
17340 " [self windowDidLoad:window];\n"
17341 " } else {\n"
17342 " [self errorLoadingWindow];\n"
17343 " }\n"
17344 " }];",
17345 format("[[SessionService sharedService]\n"
17346 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17347 " if (window) {\n"
17348 " [self windowDidLoad:window];\n"
17349 " } else {\n"
17350 " [self errorLoadingWindow];\n"
17351 " }\n"
17352 "}];",
17353 ZeroColumn));
17354 verifyFormat("[myObject doSomethingWith:arg1\n"
17355 " firstBlock:^(Foo *a) {\n"
17356 " // ...\n"
17357 " int i;\n"
17358 " }\n"
17359 " secondBlock:^(Bar *b) {\n"
17360 " // ...\n"
17361 " int i;\n"
17362 " }\n"
17363 " thirdBlock:^Foo(Bar *b) {\n"
17364 " // ...\n"
17365 " int i;\n"
17366 " }];",
17367 ZeroColumn);
17368 verifyFormat("f(^{\n"
17369 " @autoreleasepool {\n"
17370 " if (a) {\n"
17371 " g();\n"
17372 " }\n"
17373 " }\n"
17374 "});",
17375 ZeroColumn);
17376 verifyFormat("void (^largeBlock)(void) = ^{\n"
17377 " // ...\n"
17378 "};",
17379 ZeroColumn);
17380
17381 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
17382 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
17383 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
17384 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
17385 EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
17386 " int i;\n"
17387 "};",
17388 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));
17389}
17390
17391TEST_F(FormatTest, SupportsCRLF) {
17392 EXPECT_EQ("int a;\r\n"
17393 "int b;\r\n"
17394 "int c;\r\n",
17395 format("int a;\r\n"
17396 " int b;\r\n"
17397 " int c;\r\n",
17398 getLLVMStyle()));
17399 EXPECT_EQ("int a;\r\n"
17400 "int b;\r\n"
17401 "int c;\r\n",
17402 format("int a;\r\n"
17403 " int b;\n"
17404 " int c;\r\n",
17405 getLLVMStyle()));
17406 EXPECT_EQ("int a;\n"
17407 "int b;\n"
17408 "int c;\n",
17409 format("int a;\r\n"
17410 " int b;\n"
17411 " int c;\n",
17412 getLLVMStyle()));
17413 EXPECT_EQ("\"aaaaaaa \"\r\n"
17414 "\"bbbbbbb\";\r\n",
17415 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
17416 EXPECT_EQ("#define A \\\r\n"
17417 " b; \\\r\n"
17418 " c; \\\r\n"
17419 " d;\r\n",
17420 format("#define A \\\r\n"
17421 " b; \\\r\n"
17422 " c; d; \r\n",
17423 getGoogleStyle()));
17424
17425 EXPECT_EQ("/*\r\n"
17426 "multi line block comments\r\n"
17427 "should not introduce\r\n"
17428 "an extra carriage return\r\n"
17429 "*/\r\n",
17430 format("/*\r\n"
17431 "multi line block comments\r\n"
17432 "should not introduce\r\n"
17433 "an extra carriage return\r\n"
17434 "*/\r\n"));
17435 EXPECT_EQ("/*\r\n"
17436 "\r\n"
17437 "*/",
17438 format("/*\r\n"
17439 " \r\r\r\n"
17440 "*/"));
17441
17442 FormatStyle style = getLLVMStyle();
17443
17444 style.DeriveLineEnding = true;
17445 style.UseCRLF = false;
17446 EXPECT_EQ("union FooBarBazQux {\n"
17447 " int foo;\n"
17448 " int bar;\n"
17449 " int baz;\n"
17450 "};",
17451 format("union FooBarBazQux {\r\n"
17452 " int foo;\n"
17453 " int bar;\r\n"
17454 " int baz;\n"
17455 "};",
17456 style));
17457 style.UseCRLF = true;
17458 EXPECT_EQ("union FooBarBazQux {\r\n"
17459 " int foo;\r\n"
17460 " int bar;\r\n"
17461 " int baz;\r\n"
17462 "};",
17463 format("union FooBarBazQux {\r\n"
17464 " int foo;\n"
17465 " int bar;\r\n"
17466 " int baz;\n"
17467 "};",
17468 style));
17469
17470 style.DeriveLineEnding = false;
17471 style.UseCRLF = false;
17472 EXPECT_EQ("union FooBarBazQux {\n"
17473 " int foo;\n"
17474 " int bar;\n"
17475 " int baz;\n"
17476 " int qux;\n"
17477 "};",
17478 format("union FooBarBazQux {\r\n"
17479 " int foo;\n"
17480 " int bar;\r\n"
17481 " int baz;\n"
17482 " int qux;\r\n"
17483 "};",
17484 style));
17485 style.UseCRLF = true;
17486 EXPECT_EQ("union FooBarBazQux {\r\n"
17487 " int foo;\r\n"
17488 " int bar;\r\n"
17489 " int baz;\r\n"
17490 " int qux;\r\n"
17491 "};",
17492 format("union FooBarBazQux {\r\n"
17493 " int foo;\n"
17494 " int bar;\r\n"
17495 " int baz;\n"
17496 " int qux;\n"
17497 "};",
17498 style));
17499
17500 style.DeriveLineEnding = true;
17501 style.UseCRLF = false;
17502 EXPECT_EQ("union FooBarBazQux {\r\n"
17503 " int foo;\r\n"
17504 " int bar;\r\n"
17505 " int baz;\r\n"
17506 " int qux;\r\n"
17507 "};",
17508 format("union FooBarBazQux {\r\n"
17509 " int foo;\n"
17510 " int bar;\r\n"
17511 " int baz;\n"
17512 " int qux;\r\n"
17513 "};",
17514 style));
17515 style.UseCRLF = true;
17516 EXPECT_EQ("union FooBarBazQux {\n"
17517 " int foo;\n"
17518 " int bar;\n"
17519 " int baz;\n"
17520 " int qux;\n"
17521 "};",
17522 format("union FooBarBazQux {\r\n"
17523 " int foo;\n"
17524 " int bar;\r\n"
17525 " int baz;\n"
17526 " int qux;\n"
17527 "};",
17528 style));
17529}
17530
17531TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
17532 verifyFormat("MY_CLASS(C) {\n"
17533 " int i;\n"
17534 " int j;\n"
17535 "};");
17536}
17537
17538TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
17539 FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
17540 TwoIndent.ContinuationIndentWidth = 2;
17541
17542 EXPECT_EQ("int i =\n"
17543 " longFunction(\n"
17544 " arg);",
17545 format("int i = longFunction(arg);", TwoIndent));
17546
17547 FormatStyle SixIndent = getLLVMStyleWithColumns(20);
17548 SixIndent.ContinuationIndentWidth = 6;
17549
17550 EXPECT_EQ("int i =\n"
17551 " longFunction(\n"
17552 " arg);",
17553 format("int i = longFunction(arg);", SixIndent));
17554}
17555
17556TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
17557 FormatStyle Style = getLLVMStyle();
17558 verifyFormat("int Foo::getter(\n"
17559 " //\n"
17560 ") const {\n"
17561 " return foo;\n"
17562 "}",
17563 Style);
17564 verifyFormat("void Foo::setter(\n"
17565 " //\n"
17566 ") {\n"
17567 " foo = 1;\n"
17568 "}",
17569 Style);
17570}
17571
17572TEST_F(FormatTest, SpacesInAngles) {
17573 FormatStyle Spaces = getLLVMStyle();
17574 Spaces.SpacesInAngles = true;
17575
17576 verifyFormat("static_cast< int >(arg);", Spaces);
17577 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
17578 verifyFormat("f< int, float >();", Spaces);
17579 verifyFormat("template <> g() {}", Spaces);
17580 verifyFormat("template < std::vector< int > > f() {}", Spaces);
17581 verifyFormat("std::function< void(int, int) > fct;", Spaces);
17582 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
17583 Spaces);
17584
17585 Spaces.Standard = FormatStyle::LS_Cpp03;
17586 Spaces.SpacesInAngles = true;
17587 verifyFormat("A< A< int > >();", Spaces);
17588
17589 Spaces.SpacesInAngles = false;
17590 verifyFormat("A<A<int> >();", Spaces);
17591
17592 Spaces.Standard = FormatStyle::LS_Cpp11;
17593 Spaces.SpacesInAngles = true;
17594 verifyFormat("A< A< int > >();", Spaces);
17595
17596 Spaces.SpacesInAngles = false;
17597 verifyFormat("A<A<int>>();", Spaces);
17598}
17599
17600TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
17601 FormatStyle Style = getLLVMStyle();
17602 Style.SpaceAfterTemplateKeyword = false;
17603 verifyFormat("template<int> void foo();", Style);
17604}
17605
17606TEST_F(FormatTest, TripleAngleBrackets) {
17607 verifyFormat("f<<<1, 1>>>();");
17608 verifyFormat("f<<<1, 1, 1, s>>>();");
17609 verifyFormat("f<<<a, b, c, d>>>();");
17610 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
17611 verifyFormat("f<param><<<1, 1>>>();");
17612 verifyFormat("f<1><<<1, 1>>>();");
17613 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
17614 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17615 "aaaaaaaaaaa<<<\n 1, 1>>>();");
17616 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
17617 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
17618}
17619
17620TEST_F(FormatTest, MergeLessLessAtEnd) {
17621 verifyFormat("<<");
17622 EXPECT_EQ("< < <", format("\\\n<<<"));
17623 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17624 "aaallvm::outs() <<");
17625 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17626 "aaaallvm::outs()\n <<");
17627}
17628
17629TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
17630 std::string code = "#if A\n"
17631 "#if B\n"
17632 "a.\n"
17633 "#endif\n"
17634 " a = 1;\n"
17635 "#else\n"
17636 "#endif\n"
17637 "#if C\n"
17638 "#else\n"
17639 "#endif\n";
17640 EXPECT_EQ(code, format(code));
17641}
17642
17643TEST_F(FormatTest, HandleConflictMarkers) {
17644 // Git/SVN conflict markers.
17645 EXPECT_EQ("int a;\n"
17646 "void f() {\n"
17647 " callme(some(parameter1,\n"
17648 "<<<<<<< text by the vcs\n"
17649 " parameter2),\n"
17650 "||||||| text by the vcs\n"
17651 " parameter2),\n"
17652 " parameter3,\n"
17653 "======= text by the vcs\n"
17654 " parameter2, parameter3),\n"
17655 ">>>>>>> text by the vcs\n"
17656 " otherparameter);\n",
17657 format("int a;\n"
17658 "void f() {\n"
17659 " callme(some(parameter1,\n"
17660 "<<<<<<< text by the vcs\n"
17661 " parameter2),\n"
17662 "||||||| text by the vcs\n"
17663 " parameter2),\n"
17664 " parameter3,\n"
17665 "======= text by the vcs\n"
17666 " parameter2,\n"
17667 " parameter3),\n"
17668 ">>>>>>> text by the vcs\n"
17669 " otherparameter);\n"));
17670
17671 // Perforce markers.
17672 EXPECT_EQ("void f() {\n"
17673 " function(\n"
17674 ">>>> text by the vcs\n"
17675 " parameter,\n"
17676 "==== text by the vcs\n"
17677 " parameter,\n"
17678 "==== text by the vcs\n"
17679 " parameter,\n"
17680 "<<<< text by the vcs\n"
17681 " parameter);\n",
17682 format("void f() {\n"
17683 " function(\n"
17684 ">>>> text by the vcs\n"
17685 " parameter,\n"
17686 "==== text by the vcs\n"
17687 " parameter,\n"
17688 "==== text by the vcs\n"
17689 " parameter,\n"
17690 "<<<< text by the vcs\n"
17691 " parameter);\n"));
17692
17693 EXPECT_EQ("<<<<<<<\n"
17694 "|||||||\n"
17695 "=======\n"
17696 ">>>>>>>",
17697 format("<<<<<<<\n"
17698 "|||||||\n"
17699 "=======\n"
17700 ">>>>>>>"));
17701
17702 EXPECT_EQ("<<<<<<<\n"
17703 "|||||||\n"
17704 "int i;\n"
17705 "=======\n"
17706 ">>>>>>>",
17707 format("<<<<<<<\n"
17708 "|||||||\n"
17709 "int i;\n"
17710 "=======\n"
17711 ">>>>>>>"));
17712
17713 // FIXME: Handle parsing of macros around conflict markers correctly:
17714 EXPECT_EQ("#define Macro \\\n"
17715 "<<<<<<<\n"
17716 "Something \\\n"
17717 "|||||||\n"
17718 "Else \\\n"
17719 "=======\n"
17720 "Other \\\n"
17721 ">>>>>>>\n"
17722 " End int i;\n",
17723 format("#define Macro \\\n"
17724 "<<<<<<<\n"
17725 " Something \\\n"
17726 "|||||||\n"
17727 " Else \\\n"
17728 "=======\n"
17729 " Other \\\n"
17730 ">>>>>>>\n"
17731 " End\n"
17732 "int i;\n"));
17733}
17734
17735TEST_F(FormatTest, DisableRegions) {
17736 EXPECT_EQ("int i;\n"
17737 "// clang-format off\n"
17738 " int j;\n"
17739 "// clang-format on\n"
17740 "int k;",
17741 format(" int i;\n"
17742 " // clang-format off\n"
17743 " int j;\n"
17744 " // clang-format on\n"
17745 " int k;"));
17746 EXPECT_EQ("int i;\n"
17747 "/* clang-format off */\n"
17748 " int j;\n"
17749 "/* clang-format on */\n"
17750 "int k;",
17751 format(" int i;\n"
17752 " /* clang-format off */\n"
17753 " int j;\n"
17754 " /* clang-format on */\n"
17755 " int k;"));
17756
17757 // Don't reflow comments within disabled regions.
17758 EXPECT_EQ("// clang-format off\n"
17759 "// long long long long long long line\n"
17760 "/* clang-format on */\n"
17761 "/* long long long\n"
17762 " * long long long\n"
17763 " * line */\n"
17764 "int i;\n"
17765 "/* clang-format off */\n"
17766 "/* long long long long long long line */\n",
17767 format("// clang-format off\n"
17768 "// long long long long long long line\n"
17769 "/* clang-format on */\n"
17770 "/* long long long long long long line */\n"
17771 "int i;\n"
17772 "/* clang-format off */\n"
17773 "/* long long long long long long line */\n",
17774 getLLVMStyleWithColumns(20)));
17775}
17776
17777TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
17778 format("? ) =");
17779 verifyNoCrash("#define a\\\n /**/}");
17780}
17781
17782TEST_F(FormatTest, FormatsTableGenCode) {
17783 FormatStyle Style = getLLVMStyle();
17784 Style.Language = FormatStyle::LK_TableGen;
17785 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
17786}
17787
17788TEST_F(FormatTest, ArrayOfTemplates) {
17789 EXPECT_EQ("auto a = new unique_ptr<int>[10];",
17790 format("auto a = new unique_ptr<int > [ 10];"));
17791
17792 FormatStyle Spaces = getLLVMStyle();
17793 Spaces.SpacesInSquareBrackets = true;
17794 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
17795 format("auto a = new unique_ptr<int > [10];", Spaces));
17796}
17797
17798TEST_F(FormatTest, ArrayAsTemplateType) {
17799 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
17800 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
17801
17802 FormatStyle Spaces = getLLVMStyle();
17803 Spaces.SpacesInSquareBrackets = true;
17804 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
17805 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
17806}
17807
17808TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
17809
17810TEST(FormatStyle, GetStyleWithEmptyFileName) {
17811 llvm::vfs::InMemoryFileSystem FS;
17812 auto Style1 = getStyle("file", "", "Google", "", &FS);
17813 ASSERT_TRUE((bool)Style1);
17814 ASSERT_EQ(*Style1, getGoogleStyle());
17815}
17816
17817TEST(FormatStyle, GetStyleOfFile) {
17818 llvm::vfs::InMemoryFileSystem FS;
17819 // Test 1: format file in the same directory.
17820 ASSERT_TRUE(
17821 FS.addFile("/a/.clang-format", 0,
17822 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
17823 ASSERT_TRUE(
17824 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
17825 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
17826 ASSERT_TRUE((bool)Style1);
17827 ASSERT_EQ(*Style1, getLLVMStyle());
17828
17829 // Test 2.1: fallback to default.
17830 ASSERT_TRUE(
17831 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
17832 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
17833 ASSERT_TRUE((bool)Style2);
17834 ASSERT_EQ(*Style2, getMozillaStyle());
17835
17836 // Test 2.2: no format on 'none' fallback style.
17837 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
17838 ASSERT_TRUE((bool)Style2);
17839 ASSERT_EQ(*Style2, getNoStyle());
17840
17841 // Test 2.3: format if config is found with no based style while fallback is
17842 // 'none'.
17843 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
17844 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
17845 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
17846 ASSERT_TRUE((bool)Style2);
17847 ASSERT_EQ(*Style2, getLLVMStyle());
17848
17849 // Test 2.4: format if yaml with no based style, while fallback is 'none'.
17850 Style2 = getStyle("{}", "a.h", "none", "", &FS);
17851 ASSERT_TRUE((bool)Style2);
17852 ASSERT_EQ(*Style2, getLLVMStyle());
17853
17854 // Test 3: format file in parent directory.
17855 ASSERT_TRUE(
17856 FS.addFile("/c/.clang-format", 0,
17857 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
17858 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
17859 llvm::MemoryBuffer::getMemBuffer("int i;")));
17860 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
17861 ASSERT_TRUE((bool)Style3);
17862 ASSERT_EQ(*Style3, getGoogleStyle());
17863
17864 // Test 4: error on invalid fallback style
17865 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
17866 ASSERT_FALSE((bool)Style4);
17867 llvm::consumeError(Style4.takeError());
17868
17869 // Test 5: error on invalid yaml on command line
17870 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
17871 ASSERT_FALSE((bool)Style5);
17872 llvm::consumeError(Style5.takeError());
17873
17874 // Test 6: error on invalid style
17875 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
17876 ASSERT_FALSE((bool)Style6);
17877 llvm::consumeError(Style6.takeError());
17878
17879 // Test 7: found config file, error on parsing it
17880 ASSERT_TRUE(
17881 FS.addFile("/d/.clang-format", 0,
17882 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
17883 "InvalidKey: InvalidValue")));
17884 ASSERT_TRUE(
17885 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
17886 auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
17887 ASSERT_FALSE((bool)Style7a);
17888 llvm::consumeError(Style7a.takeError());
17889
17890 auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
17891 ASSERT_TRUE((bool)Style7b);
17892
17893 // Test 8: inferred per-language defaults apply.
17894 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
17895 ASSERT_TRUE((bool)StyleTd);
17896 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
17897}
17898
17899TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
17900 // Column limit is 20.
17901 std::string Code = "Type *a =\n"
17902 " new Type();\n"
17903 "g(iiiii, 0, jjjjj,\n"
17904 " 0, kkkkk, 0, mm);\n"
17905 "int bad = format ;";
17906 std::string Expected = "auto a = new Type();\n"
17907 "g(iiiii, nullptr,\n"
17908 " jjjjj, nullptr,\n"
17909 " kkkkk, nullptr,\n"
17910 " mm);\n"
17911 "int bad = format ;";
17912 FileID ID = Context.createInMemoryFile("format.cpp", Code);
17913 tooling::Replacements Replaces = toReplacements(
17914 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
17915 "auto "),
17916 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
17917 "nullptr"),
17918 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
17919 "nullptr"),
17920 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
17921 "nullptr")});
17922
17923 format::FormatStyle Style = format::getLLVMStyle();
17924 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
17925 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
17926 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
17927 << llvm::toString(FormattedReplaces.takeError()) << "\n";
17928 auto Result = applyAllReplacements(Code, *FormattedReplaces);
17929 EXPECT_TRUE(static_cast<bool>(Result));
17930 EXPECT_EQ(Expected, *Result);
17931}
17932
17933TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
17934 std::string Code = "#include \"a.h\"\n"
17935 "#include \"c.h\"\n"
17936 "\n"
17937 "int main() {\n"
17938 " return 0;\n"
17939 "}";
17940 std::string Expected = "#include \"a.h\"\n"
17941 "#include \"b.h\"\n"
17942 "#include \"c.h\"\n"
17943 "\n"
17944 "int main() {\n"
17945 " return 0;\n"
17946 "}";
17947 FileID ID = Context.createInMemoryFile("fix.cpp", Code);
17948 tooling::Replacements Replaces = toReplacements(
17949 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
17950 "#include \"b.h\"\n")});
17951
17952 format::FormatStyle Style = format::getLLVMStyle();
17953 Style.SortIncludes = true;
17954 auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
17955 EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
17956 << llvm::toString(FormattedReplaces.takeError()) << "\n";
17957 auto Result = applyAllReplacements(Code, *FormattedReplaces);
17958 EXPECT_TRUE(static_cast<bool>(Result));
17959 EXPECT_EQ(Expected, *Result);
17960}
17961
17962TEST_F(FormatTest, FormatSortsUsingDeclarations) {
17963 EXPECT_EQ("using std::cin;\n"
17964 "using std::cout;",
17965 format("using std::cout;\n"
17966 "using std::cin;",
17967 getGoogleStyle()));
17968}
17969
17970TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
17971 format::FormatStyle Style = format::getLLVMStyle();
17972 Style.Standard = FormatStyle::LS_Cpp03;
17973 // cpp03 recognize this string as identifier u8 and literal character 'a'
17974 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
17975}
17976
17977TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
17978 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
17979 // all modes, including C++11, C++14 and C++17
17980 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
17981}
17982
17983TEST_F(FormatTest, DoNotFormatLikelyXml) {
17984 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
17985 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
17986}
17987
17988TEST_F(FormatTest, StructuredBindings) {
17989 // Structured bindings is a C++17 feature.
17990 // all modes, including C++11, C++14 and C++17
17991 verifyFormat("auto [a, b] = f();");
17992 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
17993 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));
17994 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));
17995 EXPECT_EQ("auto const volatile [a, b] = f();",
17996 format("auto const volatile[a, b] = f();"));
17997 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));
17998 EXPECT_EQ("auto &[a, b, c] = f();",
17999 format("auto &[ a , b,c ] = f();"));
18000 EXPECT_EQ("auto &&[a, b, c] = f();",
18001 format("auto &&[ a , b,c ] = f();"));
18002 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();"));
18003 EXPECT_EQ("auto const volatile &&[a, b] = f();",
18004 format("auto const volatile &&[a, b] = f();"));
18005 EXPECT_EQ("auto const &&[a, b] = f();",
18006 format("auto const && [a, b] = f();"));
18007 EXPECT_EQ("const auto &[a, b] = f();",
18008 format("const auto & [a, b] = f();"));
18009 EXPECT_EQ("const auto volatile &&[a, b] = f();",
18010 format("const auto volatile &&[a, b] = f();"));
18011 EXPECT_EQ("volatile const auto &&[a, b] = f();",
18012 format("volatile const auto &&[a, b] = f();"));
18013 EXPECT_EQ("const auto &&[a, b] = f();",
18014 format("const auto && [a, b] = f();"));
18015
18016 // Make sure we don't mistake structured bindings for lambdas.
18017 FormatStyle PointerMiddle = getLLVMStyle();
18018 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
18019 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
18020 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
18021 verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
18022 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
18023 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
18024 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
18025 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
18026 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
18027 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
18028 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
18029 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
18030 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
18031
18032 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
18033 format("for (const auto && [a, b] : some_range) {\n}"));
18034 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
18035 format("for (const auto & [a, b] : some_range) {\n}"));
18036 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
18037 format("for (const auto[a, b] : some_range) {\n}"));
18038 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);"));
18039 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);"));
18040 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);"));
18041 EXPECT_EQ("auto const &[x, y](expr);",
18042 format("auto const & [x,y] (expr);"));
18043 EXPECT_EQ("auto const &&[x, y](expr);",
18044 format("auto const && [x,y] (expr);"));
18045 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};"));
18046 EXPECT_EQ("auto const &[x, y]{expr};",
18047 format("auto const & [x,y] {expr};"));
18048 EXPECT_EQ("auto const &&[x, y]{expr};",
18049 format("auto const && [x,y] {expr};"));
18050
18051 format::FormatStyle Spaces = format::getLLVMStyle();
18052 Spaces.SpacesInSquareBrackets = true;
18053 verifyFormat("auto [ a, b ] = f();", Spaces);
18054 verifyFormat("auto &&[ a, b ] = f();", Spaces);
18055 verifyFormat("auto &[ a, b ] = f();", Spaces);
18056 verifyFormat("auto const &&[ a, b ] = f();", Spaces);
18057 verifyFormat("auto const &[ a, b ] = f();", Spaces);
18058}
18059
18060TEST_F(FormatTest, FileAndCode) {
18061 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
18062 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
18063 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
18064 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
18065 EXPECT_EQ(FormatStyle::LK_ObjC,
18066 guessLanguage("foo.h", "@interface Foo\n@end\n"));
18067 EXPECT_EQ(
18068 FormatStyle::LK_ObjC,
18069 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
18070 EXPECT_EQ(FormatStyle::LK_ObjC,
18071 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
18072 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
18073 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
18074 EXPECT_EQ(FormatStyle::LK_ObjC,
18075 guessLanguage("foo", "@interface Foo\n@end\n"));
18076 EXPECT_EQ(FormatStyle::LK_ObjC,
18077 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
18078 EXPECT_EQ(
18079 FormatStyle::LK_ObjC,
18080 guessLanguage("foo.h",
18081 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
18082 EXPECT_EQ(
18083 FormatStyle::LK_Cpp,
18084 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
18085}
18086
18087TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
18088 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
18089 EXPECT_EQ(FormatStyle::LK_ObjC,
18090 guessLanguage("foo.h", "array[[calculator getIndex]];"));
18091 EXPECT_EQ(FormatStyle::LK_Cpp,
18092 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
18093 EXPECT_EQ(
18094 FormatStyle::LK_Cpp,
18095 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
18096 EXPECT_EQ(FormatStyle::LK_ObjC,
18097 guessLanguage("foo.h", "[[noreturn foo] bar];"));
18098 EXPECT_EQ(FormatStyle::LK_Cpp,
18099 guessLanguage("foo.h", "[[clang::fallthrough]];"));
18100 EXPECT_EQ(FormatStyle::LK_ObjC,
18101 guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
18102 EXPECT_EQ(FormatStyle::LK_Cpp,
18103 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
18104 EXPECT_EQ(FormatStyle::LK_Cpp,
18105 guessLanguage("foo.h", "[[using clang: fallthrough]];"));
18106 EXPECT_EQ(FormatStyle::LK_ObjC,
18107 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
18108 EXPECT_EQ(FormatStyle::LK_Cpp,
18109 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
18110 EXPECT_EQ(
18111 FormatStyle::LK_Cpp,
18112 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
18113 EXPECT_EQ(
18114 FormatStyle::LK_Cpp,
18115 guessLanguage("foo.h",
18116 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
18117 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
18118}
18119
18120TEST_F(FormatTest, GuessLanguageWithCaret) {
18121 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
18122 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
18123 EXPECT_EQ(FormatStyle::LK_ObjC,
18124 guessLanguage("foo.h", "int(^)(char, float);"));
18125 EXPECT_EQ(FormatStyle::LK_ObjC,
18126 guessLanguage("foo.h", "int(^foo)(char, float);"));
18127 EXPECT_EQ(FormatStyle::LK_ObjC,
18128 guessLanguage("foo.h", "int(^foo[10])(char, float);"));
18129 EXPECT_EQ(FormatStyle::LK_ObjC,
18130 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
18131 EXPECT_EQ(
18132 FormatStyle::LK_ObjC,
18133 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
18134}
18135
18136TEST_F(FormatTest, GuessLanguageWithPragmas) {
18137 EXPECT_EQ(FormatStyle::LK_Cpp,
18138 guessLanguage("foo.h", "__pragma(warning(disable:))"));
18139 EXPECT_EQ(FormatStyle::LK_Cpp,
18140 guessLanguage("foo.h", "#pragma(warning(disable:))"));
18141 EXPECT_EQ(FormatStyle::LK_Cpp,
18142 guessLanguage("foo.h", "_Pragma(warning(disable:))"));
18143}
18144
18145TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
18146 // ASM symbolic names are identifiers that must be surrounded by [] without
18147 // space in between:
18148 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
18149
18150 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
18151 verifyFormat(R"(//
18152asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
18153)");
18154
18155 // A list of several ASM symbolic names.
18156 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
18157
18158 // ASM symbolic names in inline ASM with inputs and outputs.
18159 verifyFormat(R"(//
18160asm("cmoveq %1, %2, %[result]"
18161 : [result] "=r"(result)
18162 : "r"(test), "r"(new), "[result]"(old));
18163)");
18164
18165 // ASM symbolic names in inline ASM with no outputs.
18166 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
18167}
18168
18169TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
18170 EXPECT_EQ(FormatStyle::LK_Cpp,
18171 guessLanguage("foo.h", "void f() {\n"
18172 " asm (\"mov %[e], %[d]\"\n"
18173 " : [d] \"=rm\" (d)\n"
18174 " [e] \"rm\" (*e));\n"
18175 "}"));
18176 EXPECT_EQ(FormatStyle::LK_Cpp,
18177 guessLanguage("foo.h", "void f() {\n"
18178 " _asm (\"mov %[e], %[d]\"\n"
18179 " : [d] \"=rm\" (d)\n"
18180 " [e] \"rm\" (*e));\n"
18181 "}"));
18182 EXPECT_EQ(FormatStyle::LK_Cpp,
18183 guessLanguage("foo.h", "void f() {\n"
18184 " __asm (\"mov %[e], %[d]\"\n"
18185 " : [d] \"=rm\" (d)\n"
18186 " [e] \"rm\" (*e));\n"
18187 "}"));
18188 EXPECT_EQ(FormatStyle::LK_Cpp,
18189 guessLanguage("foo.h", "void f() {\n"
18190 " __asm__ (\"mov %[e], %[d]\"\n"
18191 " : [d] \"=rm\" (d)\n"
18192 " [e] \"rm\" (*e));\n"
18193 "}"));
18194 EXPECT_EQ(FormatStyle::LK_Cpp,
18195 guessLanguage("foo.h", "void f() {\n"
18196 " asm (\"mov %[e], %[d]\"\n"
18197 " : [d] \"=rm\" (d),\n"
18198 " [e] \"rm\" (*e));\n"
18199 "}"));
18200 EXPECT_EQ(FormatStyle::LK_Cpp,
18201 guessLanguage("foo.h", "void f() {\n"
18202 " asm volatile (\"mov %[e], %[d]\"\n"
18203 " : [d] \"=rm\" (d)\n"
18204 " [e] \"rm\" (*e));\n"
18205 "}"));
18206}
18207
18208TEST_F(FormatTest, GuessLanguageWithChildLines) {
18209 EXPECT_EQ(FormatStyle::LK_Cpp,
18210 guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
18211 EXPECT_EQ(FormatStyle::LK_ObjC,
18212 guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
18213 EXPECT_EQ(
18214 FormatStyle::LK_Cpp,
18215 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
18216 EXPECT_EQ(
18217 FormatStyle::LK_ObjC,
18218 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
18219}
18220
18221TEST_F(FormatTest, TypenameMacros) {
18222 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
18223
18224 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
18225 FormatStyle Google = getGoogleStyleWithColumns(0);
18226 Google.TypenameMacros = TypenameMacros;
18227 verifyFormat("struct foo {\n"
18228 " int bar;\n"
18229 " TAILQ_ENTRY(a) bleh;\n"
18230 "};",
18231 Google);
18232
18233 FormatStyle Macros = getLLVMStyle();
18234 Macros.TypenameMacros = TypenameMacros;
18235
18236 verifyFormat("STACK_OF(int) a;", Macros);
18237 verifyFormat("STACK_OF(int) *a;", Macros);
18238 verifyFormat("STACK_OF(int const *) *a;", Macros);
18239 verifyFormat("STACK_OF(int *const) *a;", Macros);
18240 verifyFormat("STACK_OF(int, string) a;", Macros);
18241 verifyFormat("STACK_OF(LIST(int)) a;", Macros);
18242 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
18243 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
18244 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
18245 verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
18246 verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
18247
18248 Macros.PointerAlignment = FormatStyle::PAS_Left;
18249 verifyFormat("STACK_OF(int)* a;", Macros);
18250 verifyFormat("STACK_OF(int*)* a;", Macros);
18251 verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
18252 verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
18253 verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
18254}
18255
18256TEST_F(FormatTest, AtomicQualifier) {
18257 // Check that we treate _Atomic as a type and not a function call
18258 FormatStyle Google = getGoogleStyleWithColumns(0);
18259 verifyFormat("struct foo {\n"
18260 " int a1;\n"
18261 " _Atomic(a) a2;\n"
18262 " _Atomic(_Atomic(int) *const) a3;\n"
18263 "};",
18264 Google);
18265 verifyFormat("_Atomic(uint64_t) a;");
18266 verifyFormat("_Atomic(uint64_t) *a;");
18267 verifyFormat("_Atomic(uint64_t const *) *a;");
18268 verifyFormat("_Atomic(uint64_t *const) *a;");
18269 verifyFormat("_Atomic(const uint64_t *) *a;");
18270 verifyFormat("_Atomic(uint64_t) a;");
18271 verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
18272 verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
18273 verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
18274 verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
18275
18276 verifyFormat("_Atomic(uint64_t) *s(InitValue);");
18277 verifyFormat("_Atomic(uint64_t) *s{InitValue};");
18278 FormatStyle Style = getLLVMStyle();
18279 Style.PointerAlignment = FormatStyle::PAS_Left;
18280 verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
18281 verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
18282 verifyFormat("_Atomic(int)* a;", Style);
18283 verifyFormat("_Atomic(int*)* a;", Style);
18284 verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
18285
18286 Style.SpacesInCStyleCastParentheses = true;
18287 Style.SpacesInParentheses = false;
18288 verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
18289 Style.SpacesInCStyleCastParentheses = false;
18290 Style.SpacesInParentheses = true;
18291 verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
18292 verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
18293}
18294
18295TEST_F(FormatTest, AmbersandInLamda) {
18296 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
18297 FormatStyle AlignStyle = getLLVMStyle();
18298 AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
18299 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
18300 AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
18301 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
18302}
18303
18304TEST_F(FormatTest, SpacesInConditionalStatement) {
18305 FormatStyle Spaces = getLLVMStyle();
18306 Spaces.SpacesInConditionalStatement = true;
18307 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces);
18308 verifyFormat("if ( !a )\n return;", Spaces);
18309 verifyFormat("if ( a )\n return;", Spaces);
18310 verifyFormat("if constexpr ( a )\n return;", Spaces);
18311 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces);
18312 verifyFormat("while ( a )\n return;", Spaces);
18313 verifyFormat("while ( (a && b) )\n return;", Spaces);
18314 verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
18315 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
18316 // Check that space on the left of "::" is inserted as expected at beginning
18317 // of condition.
18318 verifyFormat("while ( ::func() )\n return;", Spaces);
18319}
18320
18321TEST_F(FormatTest, AlternativeOperators) {
18322 // Test case for ensuring alternate operators are not
18323 // combined with their right most neighbour.
18324 verifyFormat("int a and b;");
18325 verifyFormat("int a and_eq b;");
18326 verifyFormat("int a bitand b;");
18327 verifyFormat("int a bitor b;");
18328 verifyFormat("int a compl b;");
18329 verifyFormat("int a not b;");
18330 verifyFormat("int a not_eq b;");
18331 verifyFormat("int a or b;");
18332 verifyFormat("int a xor b;");
18333 verifyFormat("int a xor_eq b;");
18334 verifyFormat("return this not_eq bitand other;");
18335 verifyFormat("bool operator not_eq(const X bitand other)");
18336
18337 verifyFormat("int a and 5;");
18338 verifyFormat("int a and_eq 5;");
18339 verifyFormat("int a bitand 5;");
18340 verifyFormat("int a bitor 5;");
18341 verifyFormat("int a compl 5;");
18342 verifyFormat("int a not 5;");
18343 verifyFormat("int a not_eq 5;");
18344 verifyFormat("int a or 5;");
18345 verifyFormat("int a xor 5;");
18346 verifyFormat("int a xor_eq 5;");
18347
18348 verifyFormat("int a compl(5);");
18349 verifyFormat("int a not(5);");
18350
18351 /* FIXME handle alternate tokens
18352 * https://en.cppreference.com/w/cpp/language/operator_alternative
18353 // alternative tokens
18354 verifyFormat("compl foo();"); // ~foo();
18355 verifyFormat("foo() <%%>;"); // foo();
18356 verifyFormat("void foo() <%%>;"); // void foo(){}
18357 verifyFormat("int a <:1:>;"); // int a[1];[
18358 verifyFormat("%:define ABC abc"); // #define ABC abc
18359 verifyFormat("%:%:"); // ##
18360 */
18361}
18362
18363TEST_F(FormatTest, STLWhileNotDefineChed) {
18364 verifyFormat("#if defined(while)\n"
18365 "#define while EMIT WARNING C4005\n"
18366 "#endif // while");
18367}
18368
18369TEST_F(FormatTest, OperatorSpacing) {
18370 FormatStyle Style = getLLVMStyle();
18371 Style.PointerAlignment = FormatStyle::PAS_Right;
18372 verifyFormat("Foo::operator*();", Style);
18373 verifyFormat("Foo::operator void *();", Style);
18374 verifyFormat("Foo::operator void **();", Style);
18375 verifyFormat("Foo::operator void *&();", Style);
18376 verifyFormat("Foo::operator void *&&();", Style);
18377 verifyFormat("Foo::operator()(void *);", Style);
18378 verifyFormat("Foo::operator*(void *);", Style);
18379 verifyFormat("Foo::operator*();", Style);
18380 verifyFormat("Foo::operator**();", Style);
18381 verifyFormat("Foo::operator&();", Style);
18382 verifyFormat("Foo::operator<int> *();", Style);
18383 verifyFormat("Foo::operator<Foo> *();", Style);
18384 verifyFormat("Foo::operator<int> **();", Style);
18385 verifyFormat("Foo::operator<Foo> **();", Style);
18386 verifyFormat("Foo::operator<int> &();", Style);
18387 verifyFormat("Foo::operator<Foo> &();", Style);
18388 verifyFormat("Foo::operator<int> &&();", Style);
18389 verifyFormat("Foo::operator<Foo> &&();", Style);
18390 verifyFormat("Foo::operator<int> *&();", Style);
18391 verifyFormat("Foo::operator<Foo> *&();", Style);
18392 verifyFormat("Foo::operator<int> *&&();", Style);
18393 verifyFormat("Foo::operator<Foo> *&&();", Style);
18394 verifyFormat("operator*(int (*)(), class Foo);", Style);
18395
18396 verifyFormat("Foo::operator&();", Style);
18397 verifyFormat("Foo::operator void &();", Style);
18398 verifyFormat("Foo::operator()(void &);", Style);
18399 verifyFormat("Foo::operator&(void &);", Style);
18400 verifyFormat("Foo::operator&();", Style);
18401 verifyFormat("operator&(int (&)(), class Foo);", Style);
18402
18403 verifyFormat("Foo::operator&&();", Style);
18404 verifyFormat("Foo::operator**();", Style);
18405 verifyFormat("Foo::operator void &&();", Style);
18406 verifyFormat("Foo::operator()(void &&);", Style);
18407 verifyFormat("Foo::operator&&(void &&);", Style);
18408 verifyFormat("Foo::operator&&();", Style);
18409 verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18410 verifyFormat("operator const nsTArrayRight<E> &()", Style);
18411 verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
18412 Style);
18413 verifyFormat("operator void **()", Style);
18414 verifyFormat("operator const FooRight<Object> &()", Style);
18415 verifyFormat("operator const FooRight<Object> *()", Style);
18416 verifyFormat("operator const FooRight<Object> **()", Style);
18417 verifyFormat("operator const FooRight<Object> *&()", Style);
18418 verifyFormat("operator const FooRight<Object> *&&()", Style);
18419
18420 Style.PointerAlignment = FormatStyle::PAS_Left;
18421 verifyFormat("Foo::operator*();", Style);
18422 verifyFormat("Foo::operator**();", Style);
18423 verifyFormat("Foo::operator void*();", Style);
18424 verifyFormat("Foo::operator void**();", Style);
18425 verifyFormat("Foo::operator void*&();", Style);
18426 verifyFormat("Foo::operator/*comment*/ void*();", Style);
18427 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
18428 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
18429 verifyFormat("Foo::operator()(void*);", Style);
18430 verifyFormat("Foo::operator*(void*);", Style);
18431 verifyFormat("Foo::operator*();", Style);
18432 verifyFormat("Foo::operator<int>*();", Style);
18433 verifyFormat("Foo::operator<Foo>*();", Style);
18434 verifyFormat("Foo::operator<int>**();", Style);
18435 verifyFormat("Foo::operator<Foo>**();", Style);
18436 verifyFormat("Foo::operator<Foo>*&();", Style);
18437 verifyFormat("Foo::operator<int>&();", Style);
18438 verifyFormat("Foo::operator<Foo>&();", Style);
18439 verifyFormat("Foo::operator<int>&&();", Style);
18440 verifyFormat("Foo::operator<Foo>&&();", Style);
18441 verifyFormat("Foo::operator<int>*&();", Style);
18442 verifyFormat("Foo::operator<Foo>*&();", Style);
18443 verifyFormat("operator*(int (*)(), class Foo);", Style);
18444
18445 verifyFormat("Foo::operator&();", Style);
18446 verifyFormat("Foo::operator void&();", Style);
18447 verifyFormat("Foo::operator/*comment*/ void&();", Style);
18448 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
18449 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
18450 verifyFormat("Foo::operator()(void&);", Style);
18451 verifyFormat("Foo::operator&(void&);", Style);
18452 verifyFormat("Foo::operator&();", Style);
18453 verifyFormat("operator&(int (&)(), class Foo);", Style);
18454
18455 verifyFormat("Foo::operator&&();", Style);
18456 verifyFormat("Foo::operator void&&();", Style);
18457 verifyFormat("Foo::operator/*comment*/ void&&();", Style);
18458 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
18459 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
18460 verifyFormat("Foo::operator()(void&&);", Style);
18461 verifyFormat("Foo::operator&&(void&&);", Style);
18462 verifyFormat("Foo::operator&&();", Style);
18463 verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18464 verifyFormat("operator const nsTArrayLeft<E>&()", Style);
18465 verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
18466 Style);
18467 verifyFormat("operator void**()", Style);
18468 verifyFormat("operator const FooLeft<Object>&()", Style);
18469 verifyFormat("operator const FooLeft<Object>*()", Style);
18470 verifyFormat("operator const FooLeft<Object>**()", Style);
18471 verifyFormat("operator const FooLeft<Object>*&()", Style);
18472 verifyFormat("operator const FooLeft<Object>*&&()", Style);
18473
18474 // PR45107
18475 verifyFormat("operator Vector<String>&();", Style);
18476 verifyFormat("operator const Vector<String>&();", Style);
18477 verifyFormat("operator foo::Bar*();", Style);
18478 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
18479 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
18480 Style);
18481
18482 Style.PointerAlignment = FormatStyle::PAS_Middle;
18483 verifyFormat("Foo::operator*();", Style);
18484 verifyFormat("Foo::operator void *();", Style);
18485 verifyFormat("Foo::operator()(void *);", Style);
18486 verifyFormat("Foo::operator*(void *);", Style);
18487 verifyFormat("Foo::operator*();", Style);
18488 verifyFormat("operator*(int (*)(), class Foo);", Style);
18489
18490 verifyFormat("Foo::operator&();", Style);
18491 verifyFormat("Foo::operator void &();", Style);
18492 verifyFormat("Foo::operator()(void &);", Style);
18493 verifyFormat("Foo::operator&(void &);", Style);
18494 verifyFormat("Foo::operator&();", Style);
18495 verifyFormat("operator&(int (&)(), class Foo);", Style);
18496
18497 verifyFormat("Foo::operator&&();", Style);
18498 verifyFormat("Foo::operator void &&();", Style);
18499 verifyFormat("Foo::operator()(void &&);", Style);
18500 verifyFormat("Foo::operator&&(void &&);", Style);
18501 verifyFormat("Foo::operator&&();", Style);
18502 verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18503}
18504
18505TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
18506 FormatStyle Style = getLLVMStyle();
18507 // PR46157
18508 verifyFormat("foo(operator+, -42);", Style);
18509 verifyFormat("foo(operator++, -42);", Style);
18510 verifyFormat("foo(operator--, -42);", Style);
18511 verifyFormat("foo(-42, operator--);", Style);
18512 verifyFormat("foo(-42, operator, );", Style);
18513 verifyFormat("foo(operator, , -42);", Style);
18514}
18515
18516TEST_F(FormatTest, WhitespaceSensitiveMacros) {
18517 FormatStyle Style = getLLVMStyle();
18518 Style.WhitespaceSensitiveMacros.push_back("FOO");
18519
18520 // Don't use the helpers here, since 'mess up' will change the whitespace
18521 // and these are all whitespace sensitive by definition
18522 EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
18523 format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
18524 EXPECT_EQ(
18525 "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
18526 format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
18527 EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
18528 format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
18529 EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
18530 " Still=Intentional);",
18531 format("FOO(String-ized&Messy+But,: :\n"
18532 " Still=Intentional);",
18533 Style));
18534 Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
18535 EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
18536 " Still=Intentional);",
18537 format("FOO(String-ized=&Messy+But,: :\n"
18538 " Still=Intentional);",
18539 Style));
18540
18541 Style.ColumnLimit = 21;
18542 EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
18543 format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
18544}
18545
18546TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
18547 // These tests are not in NamespaceFixer because that doesn't
18548 // test its interaction with line wrapping
18549 FormatStyle Style = getLLVMStyle();
18550 Style.ColumnLimit = 80;
18551 verifyFormat("namespace {\n"
18552 "int i;\n"
18553 "int j;\n"
18554 "} // namespace",
18555 Style);
18556
18557 verifyFormat("namespace AAA {\n"
18558 "int i;\n"
18559 "int j;\n"
18560 "} // namespace AAA",
18561 Style);
18562
18563 EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
18564 "int i;\n"
18565 "int j;\n"
18566 "} // namespace Averyveryveryverylongnamespace",
18567 format("namespace Averyveryveryverylongnamespace {\n"
18568 "int i;\n"
18569 "int j;\n"
18570 "}",
18571 Style));
18572
18573 EXPECT_EQ(
18574 "namespace "
18575 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
18576 " went::mad::now {\n"
18577 "int i;\n"
18578 "int j;\n"
18579 "} // namespace\n"
18580 " // "
18581 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
18582 "went::mad::now",
18583 format("namespace "
18584 "would::it::save::you::a::lot::of::time::if_::i::"
18585 "just::gave::up::and_::went::mad::now {\n"
18586 "int i;\n"
18587 "int j;\n"
18588 "}",
18589 Style));
18590
18591 // This used to duplicate the comment again and again on subsequent runs
18592 EXPECT_EQ(
18593 "namespace "
18594 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
18595 " went::mad::now {\n"
18596 "int i;\n"
18597 "int j;\n"
18598 "} // namespace\n"
18599 " // "
18600 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
18601 "went::mad::now",
18602 format("namespace "
18603 "would::it::save::you::a::lot::of::time::if_::i::"
18604 "just::gave::up::and_::went::mad::now {\n"
18605 "int i;\n"
18606 "int j;\n"
18607 "} // namespace\n"
18608 " // "
18609 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
18610 "and_::went::mad::now",
18611 Style));
18612}
18613
18614TEST_F(FormatTest, LikelyUnlikely) {
18615 FormatStyle Style = getLLVMStyle();
18616
18617 verifyFormat("if (argc > 5) [[unlikely]] {\n"
18618 " return 29;\n"
18619 "}",
18620 Style);
18621
18622 verifyFormat("if (argc > 5) [[likely]] {\n"
18623 " return 29;\n"
18624 "}",
18625 Style);
18626
18627 verifyFormat("if (argc > 5) [[unlikely]] {\n"
18628 " return 29;\n"
18629 "} else [[likely]] {\n"
18630 " return 42;\n"
18631 "}\n",
18632 Style);
18633
18634 verifyFormat("if (argc > 5) [[unlikely]] {\n"
18635 " return 29;\n"
18636 "} else if (argc > 10) [[likely]] {\n"
18637 " return 99;\n"
18638 "} else {\n"
18639 " return 42;\n"
18640 "}\n",
18641 Style);
18642
18643 verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
18644 " return 29;\n"
18645 "}",
18646 Style);
18647}
18648
18649TEST_F(FormatTest, PenaltyIndentedWhitespace) {
18650 verifyFormat("Constructor()\n"
18651 " : aaaaaa(aaaaaa), aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
18652 " aaaa(aaaaaaaaaaaaaaaaaa, "
18653 "aaaaaaaaaaaaaaaaaat))");
18654 verifyFormat("Constructor()\n"
18655 " : aaaaaaaaaaaaa(aaaaaa), "
18656 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)");
18657
18658 FormatStyle StyleWithWhitespacePenalty = getLLVMStyle();
18659 StyleWithWhitespacePenalty.PenaltyIndentedWhitespace = 5;
18660 verifyFormat("Constructor()\n"
18661 " : aaaaaa(aaaaaa),\n"
18662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
18663 " aaaa(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaat))",
18664 StyleWithWhitespacePenalty);
18665 verifyFormat("Constructor()\n"
18666 " : aaaaaaaaaaaaa(aaaaaa), "
18667 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)",
18668 StyleWithWhitespacePenalty);
18669}
18670
18671TEST_F(FormatTest, LLVMDefaultStyle) {
18672 FormatStyle Style = getLLVMStyle();
18673 verifyFormat("extern \"C\" {\n"
18674 "int foo();\n"
18675 "}",
18676 Style);
18677}
18678TEST_F(FormatTest, GNUDefaultStyle) {
18679 FormatStyle Style = getGNUStyle();
18680 verifyFormat("extern \"C\"\n"
18681 "{\n"
18682 " int foo ();\n"
18683 "}",
18684 Style);
18685}
18686TEST_F(FormatTest, MozillaDefaultStyle) {
18687 FormatStyle Style = getMozillaStyle();
18688 verifyFormat("extern \"C\"\n"
18689 "{\n"
18690 " int foo();\n"
18691 "}",
18692 Style);
18693}
18694TEST_F(FormatTest, GoogleDefaultStyle) {
18695 FormatStyle Style = getGoogleStyle();
18696 verifyFormat("extern \"C\" {\n"
18697 "int foo();\n"
18698 "}",
18699 Style);
18700}
18701TEST_F(FormatTest, ChromiumDefaultStyle) {
18702 FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
18703 verifyFormat("extern \"C\" {\n"
18704 "int foo();\n"
18705 "}",
18706 Style);
18707}
18708TEST_F(FormatTest, MicrosoftDefaultStyle) {
18709 FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
18710 verifyFormat("extern \"C\"\n"
18711 "{\n"
18712 " int foo();\n"
18713 "}",
18714 Style);
18715}
18716TEST_F(FormatTest, WebKitDefaultStyle) {
18717 FormatStyle Style = getWebKitStyle();
18718 verifyFormat("extern \"C\" {\n"
18719 "int foo();\n"
18720 "}",
18721 Style);
18722}
18723
18724TEST_F(FormatTest, ConceptsAndRequires) {
18725 FormatStyle Style = getLLVMStyle();
18726 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
18727
18728 verifyFormat("template <typename T>\n"
18729 "concept Hashable = requires(T a) {\n"
18730 " { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
18731 "};",
18732 Style);
18733 verifyFormat("template <typename T>\n"
18734 "concept EqualityComparable = requires(T a, T b) {\n"
18735 " { a == b } -> bool;\n"
18736 "};",
18737 Style);
18738 verifyFormat("template <typename T>\n"
18739 "concept EqualityComparable = requires(T a, T b) {\n"
18740 " { a == b } -> bool;\n"
18741 " { a != b } -> bool;\n"
18742 "};",
18743 Style);
18744 verifyFormat("template <typename T>\n"
18745 "concept EqualityComparable = requires(T a, T b) {\n"
18746 " { a == b } -> bool;\n"
18747 " { a != b } -> bool;\n"
18748 "};",
18749 Style);
18750
18751 verifyFormat("template <typename It>\n"
18752 "requires Iterator<It>\n"
18753 "void sort(It begin, It end) {\n"
18754 " //....\n"
18755 "}",
18756 Style);
18757
18758 verifyFormat("template <typename T>\n"
18759 "concept Large = sizeof(T) > 10;",
18760 Style);
18761
18762 verifyFormat("template <typename T, typename U>\n"
18763 "concept FooableWith = requires(T t, U u) {\n"
18764 " typename T::foo_type;\n"
18765 " { t.foo(u) } -> typename T::foo_type;\n"
18766 " t++;\n"
18767 "};\n"
18768 "void doFoo(FooableWith<int> auto t) {\n"
18769 " t.foo(3);\n"
18770 "}",
18771 Style);
18772 verifyFormat("template <typename T>\n"
18773 "concept Context = sizeof(T) == 1;",
18774 Style);
18775 verifyFormat("template <typename T>\n"
18776 "concept Context = is_specialization_of_v<context, T>;",
18777 Style);
18778 verifyFormat("template <typename T>\n"
18779 "concept Node = std::is_object_v<T>;",
18780 Style);
18781 verifyFormat("template <typename T>\n"
18782 "concept Tree = true;",
18783 Style);
18784
18785 verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
18786 " //...\n"
18787 "}",
18788 Style);
18789
18790 verifyFormat(
18791 "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
18792 " //...\n"
18793 "}",
18794 Style);
18795
18796 verifyFormat(
18797 "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
18798 " //...\n"
18799 "}",
18800 Style);
18801
18802 verifyFormat("template <typename T>\n"
18803 "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
18804 "Concept2<I> {\n"
18805 " //...\n"
18806 "}",
18807 Style);
18808
18809 verifyFormat("template <typename T>\n"
18810 "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
18811 "Concept2<I> {\n"
18812 " //...\n"
18813 "}",
18814 Style);
18815
18816 verifyFormat(
18817 "template <typename T>\n"
18818 "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
18819 " //...\n"
18820 "}",
18821 Style);
18822
18823 verifyFormat(
18824 "template <typename T>\n"
18825 "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
18826 " //...\n"
18827 "}",
18828 Style);
18829
18830 verifyFormat("template <typename It>\n"
18831 "requires Foo<It>() && Bar<It> {\n"
18832 " //....\n"
18833 "}",
18834 Style);
18835
18836 verifyFormat("template <typename It>\n"
18837 "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
18838 " //....\n"
18839 "}",
18840 Style);
18841
18842 verifyFormat("template <typename It>\n"
18843 "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
18844 " //....\n"
18845 "}",
18846 Style);
18847
18848 verifyFormat(
18849 "template <typename It>\n"
18850 "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
18851 " //....\n"
18852 "}",
18853 Style);
18854
18855 Style.IndentRequires = true;
18856 verifyFormat("template <typename It>\n"
18857 " requires Iterator<It>\n"
18858 "void sort(It begin, It end) {\n"
18859 " //....\n"
18860 "}",
18861 Style);
18862 verifyFormat("template <std::size index_>\n"
18863 " requires(index_ < sizeof...(Children_))\n"
18864 "Tree auto &child() {\n"
18865 " // ...\n"
18866 "}",
18867 Style);
18868
18869 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
18870 verifyFormat("template <typename T>\n"
18871 "concept Hashable = requires (T a) {\n"
18872 " { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
18873 "};",
18874 Style);
18875
18876 verifyFormat("template <class T = void>\n"
18877 " requires EqualityComparable<T> || Same<T, void>\n"
18878 "struct equal_to;",
18879 Style);
18880
18881 verifyFormat("template <class T>\n"
18882 " requires requires {\n"
18883 " T{};\n"
18884 " T (int);\n"
18885 " }\n",
18886 Style);
18887
18888 Style.ColumnLimit = 78;
18889 verifyFormat("template <typename T>\n"
18890 "concept Context = Traits<typename T::traits_type> and\n"
18891 " Interface<typename T::interface_type> and\n"
18892 " Request<typename T::request_type> and\n"
18893 " Response<typename T::response_type> and\n"
18894 " ContextExtension<typename T::extension_type> and\n"
18895 " ::std::is_copy_constructable<T> and "
18896 "::std::is_move_constructable<T> and\n"
18897 " requires (T c) {\n"
18898 " { c.response; } -> Response;\n"
18899 "} and requires (T c) {\n"
18900 " { c.request; } -> Request;\n"
18901 "}\n",
18902 Style);
18903
18904 verifyFormat("template <typename T>\n"
18905 "concept Context = Traits<typename T::traits_type> or\n"
18906 " Interface<typename T::interface_type> or\n"
18907 " Request<typename T::request_type> or\n"
18908 " Response<typename T::response_type> or\n"
18909 " ContextExtension<typename T::extension_type> or\n"
18910 " ::std::is_copy_constructable<T> or "
18911 "::std::is_move_constructable<T> or\n"
18912 " requires (T c) {\n"
18913 " { c.response; } -> Response;\n"
18914 "} or requires (T c) {\n"
18915 " { c.request; } -> Request;\n"
18916 "}\n",
18917 Style);
18918
18919 verifyFormat("template <typename T>\n"
18920 "concept Context = Traits<typename T::traits_type> &&\n"
18921 " Interface<typename T::interface_type> &&\n"
18922 " Request<typename T::request_type> &&\n"
18923 " Response<typename T::response_type> &&\n"
18924 " ContextExtension<typename T::extension_type> &&\n"
18925 " ::std::is_copy_constructable<T> && "
18926 "::std::is_move_constructable<T> &&\n"
18927 " requires (T c) {\n"
18928 " { c.response; } -> Response;\n"
18929 "} && requires (T c) {\n"
18930 " { c.request; } -> Request;\n"
18931 "}\n",
18932 Style);
18933
18934 verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
18935 "Constraint2<T>;");
18936
18937 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
18938 Style.BraceWrapping.AfterFunction = true;
18939 Style.BraceWrapping.AfterClass = true;
18940 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
18941 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
18942 verifyFormat("void Foo () requires (std::copyable<T>)\n"
18943 "{\n"
18944 " return\n"
18945 "}\n",
18946 Style);
18947
18948 verifyFormat("void Foo () requires std::copyable<T>\n"
18949 "{\n"
18950 " return\n"
18951 "}\n",
18952 Style);
18953
18954 verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
18955 " requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
18956 "struct constant;",
18957 Style);
18958
18959 verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
18960 " requires std::invocable<F, std::invoke_result_t<Args>...>\n"
18961 "struct constant;",
18962 Style);
18963
18964 verifyFormat("template <class T>\n"
18965 "class plane_with_very_very_very_long_name\n"
18966 "{\n"
18967 " constexpr plane_with_very_very_very_long_name () requires "
18968 "std::copyable<T>\n"
18969 " : plane_with_very_very_very_long_name (1)\n"
18970 " {\n"
18971 " }\n"
18972 "}\n",
18973 Style);
18974
18975 verifyFormat("template <class T>\n"
18976 "class plane_with_long_name\n"
18977 "{\n"
18978 " constexpr plane_with_long_name () requires std::copyable<T>\n"
18979 " : plane_with_long_name (1)\n"
18980 " {\n"
18981 " }\n"
18982 "}\n",
18983 Style);
18984
18985 Style.BreakBeforeConceptDeclarations = false;
18986 verifyFormat("template <typename T> concept Tree = true;", Style);
18987
18988 Style.IndentRequires = false;
18989 verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
18990 "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
18991 "struct constant;",
18992 Style);
18993}
18994
18995TEST_F(FormatTest, StatementAttributeLikeMacros) {
18996 FormatStyle Style = getLLVMStyle();
18997 StringRef Source = "void Foo::slot() {\n"
18998 " unsigned char MyChar = 'x';\n"
18999 " emit signal(MyChar);\n"
19000 " Q_EMIT signal(MyChar);\n"
19001 "}";
19002
19003 EXPECT_EQ(Source, format(Source, Style));
19004
19005 Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
19006 EXPECT_EQ("void Foo::slot() {\n"
19007 " unsigned char MyChar = 'x';\n"
19008 " emit signal(MyChar);\n"
19009 " Q_EMIT signal(MyChar);\n"
19010 "}",
19011 format(Source, Style));
19012
19013 Style.StatementAttributeLikeMacros.push_back("emit");
19014 EXPECT_EQ(Source, format(Source, Style));
19015
19016 Style.StatementAttributeLikeMacros = {};
19017 EXPECT_EQ("void Foo::slot() {\n"
19018 " unsigned char MyChar = 'x';\n"
19019 " emit signal(MyChar);\n"
19020 " Q_EMIT signal(MyChar);\n"
19021 "}",
19022 format(Source, Style));
19023}
19024} // namespace
19025} // namespace format
19026} // namespace clang
19027